@agentikos/omega-os 0.1.0 → 0.19.5

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),
+    ]

package/omega/Agentik_Engine/omega_engine/pursue.py

@@ -0,0 +1,205 @@
+"""pursue — goal-driven execution loop.
+
+The Agentik OS native equivalent of a goal-driven worker. Takes a
+``verify_cmd`` and an ``intent``. Iterates: ask the provider to act, run
+``verify_cmd``, if exit 0 → success; otherwise feed the failure back and
+iterate. Caps at ``max_iterations`` and writes a per-iteration log.
+
+Why this exists:
+  Claude Code's bundled ``/goal`` does this in the editor. We rebuild it
+  as a portable engine primitive so OmegaOS workers (running in any
+  context — daemon, CLI, autonomous charter) can use the same loop without
+  depending on a specific bundled skill we don't control.
+
+Output:
+  Each iteration appends to ``Agentik_Runtime/sessions/<task_id>/pursue.log``
+  with ``{iteration, attempted_change, verify_exit, verify_tail}``.
+  On success, writes a ``done.json`` (via ``omega_engine.done_signal``)
+  with ``status=done_clean`` and a summary. On budget exhaustion, the same
+  but with ``status=failed`` and the cumulative attempts as ``errors``.
+
+The provider used is the engine's normal ModelRouter — works with the
+MockProvider in tests and with ClaudeProvider in production.
+"""
+from __future__ import annotations
+
+import json
+import os
+import shlex
+import subprocess
+import time
+import uuid
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Any
+
+
+@dataclass
+class PursueResult:
+    task_id: str
+    status: str                              # "done_clean" | "failed"
+    iterations: int
+    final_verify_exit: int | None
+    log_path: Path
+    done_path: Path
+    artifacts: dict[str, Any] = field(default_factory=dict)
+
+
+def _run_verify(verify_cmd: str, *, cwd: str | None = None,
+                timeout: int = 600) -> tuple[int, str]:
+    """Run the verify command in a shell and capture (exit_code, tail-of-output).
+
+    Returns a 2-tuple. ``tail`` is the last ~80 lines of stdout+stderr so we
+    can feed it back to the provider as the iteration's "what broke" context.
+    """
+    try:
+        proc = subprocess.run(
+            verify_cmd, shell=True, check=False, capture_output=True,
+            text=True, timeout=timeout, cwd=cwd,
+        )
+    except subprocess.TimeoutExpired:
+        return 124, "(verify_cmd timed out)"
+    out = (proc.stdout or "") + (proc.stderr or "")
+    tail = "\n".join(out.splitlines()[-80:])
+    return proc.returncode, tail
+
+
+def pursue(
+    intent: str,
+    verify_cmd: str,
+    *,
+    omega_home: str | Path | None = None,
+    task_id: str | None = None,
+    project: str | None = None,
+    max_iterations: int = 20,
+    cwd: str | None = None,
+    role: str = "worker",
+    timeout_per_iter: int = 600,
+    router=None,
+) -> PursueResult:
+    """Drive an agent toward a goal until ``verify_cmd`` exits 0.
+
+    Args:
+        intent: the natural-language goal the agent is pursuing.
+        verify_cmd: the shell command that proves the goal is met (exit 0).
+        omega_home: ``$OMEGA_HOME`` (defaults to env or ``~/Omega``).
+        task_id: optional id; one is generated if not provided.
+        project: project slug; if set, the cwd defaults to that project's
+            directory and per-project artefacts live there.
+        max_iterations: hard cap on attempts (default 20).
+        cwd: working directory for ``verify_cmd``. Defaults to project path
+            when ``project`` is set, else current directory.
+        role: provider role to use (default ``worker``).
+        timeout_per_iter: timeout (seconds) per provider call + verify pair.
+        router: an ``omega_engine.router.ModelRouter`` — defaults to one
+            built from env (mock if no real provider configured).
+
+    Returns: a ``PursueResult`` describing the outcome.
+    """
+    home = Path(omega_home or os.environ.get("OMEGA_HOME") or
+                Path.home() / "Omega")
+    task_id = task_id or "pur-" + uuid.uuid4().hex[:8]
+
+    # Local imports — keep this module's import-cost low.
+    from omega_engine.done_signal import DoneSignal, session_dir, write_done
+    from omega_engine.envelope import EnvelopeContext, build_envelope
+    from omega_engine.provider import AgentRequest
+
+    if router is None:
+        from omega_engine.router import ModelRouter
+        from omega_engine.provider import MockProvider
+        router = ModelRouter.single(MockProvider())
+
+    # Resolve cwd from project if not explicit.
+    if cwd is None and project:
+        cwd = str(home / "Agentik_Coding" / "projects" / project)
+    cwd = cwd or os.getcwd()
+
+    sess = session_dir(home, task_id)
+    log_path = sess / "pursue.log"
+    done_p = sess / ".done.json"
+
+    def log_iter(payload: dict[str, Any]) -> None:
+        with open(log_path, "a") as fh:
+            fh.write(json.dumps({"ts": int(time.time()), **payload}) + "\n")
+
+    provider = router.resolve(role)
+    last_exit: int | None = None
+    last_tail: str = ""
+    attempts: list[dict[str, Any]] = []
+
+    for i in range(1, max_iterations + 1):
+        # Build a rich envelope: the agent sees the goal, the verify_cmd,
+        # the previous failure tail, and its done.json contract.
+        ctx = EnvelopeContext(
+            role=role,
+            intent=(
+                f"GOAL: {intent}\n\n"
+                f"VERIFY: `{verify_cmd}` (must exit 0 to be done).\n\n"
+                + (f"PREVIOUS FAILURE (iter {i - 1}, exit {last_exit}):\n"
+                   f"```\n{last_tail}\n```\n" if i > 1 else "")
+                + f"This is iteration {i} of {max_iterations}. "
+                f"Make one focused, surgical change."
+            ),
+            task_id=task_id,
+            verify_cmd=verify_cmd,
+            done_json_path=str(done_p),
+            project={"slug": project, "path": cwd} if project else None,
+        )
+        envelope = build_envelope(home, ctx)
+        request = AgentRequest(
+            role=role, prompt=envelope["user"], context={
+                "task": intent, "verify_cmd": verify_cmd,
+            }, system=envelope["system"],
+        )
+
+        try:
+            result = provider.run(request)
+        except Exception as exc:  # noqa: BLE001
+            log_iter({"iter": i, "provider_error": str(exc)[:300]})
+            attempts.append({"iter": i, "error": str(exc)[:300]})
+            continue
+
+        # Run verify after the provider's turn.
+        exit_code, tail = _run_verify(
+            verify_cmd, cwd=cwd, timeout=timeout_per_iter,
+        )
+        last_exit = exit_code
+        last_tail = tail
+        log_iter({
+            "iter": i, "verify_exit": exit_code,
+            "provider_text": (result.text or "")[:300],
+            "verify_tail": tail[-400:],
+        })
+        attempts.append({"iter": i, "exit": exit_code})
+
+        if exit_code == 0:
+            sig = DoneSignal(
+                status="done_clean",
+                summary=f"goal '{intent}' verified by `{verify_cmd}` in {i} iter(s)",
+                artifacts={"attempts": attempts, "log": str(log_path)},
+                files_changed=list(result.artifacts.get("files") or []),
+            )
+            write_done(home, task_id, sig)
+            return PursueResult(
+                task_id=task_id, status="done_clean", iterations=i,
+                final_verify_exit=0, log_path=log_path, done_path=done_p,
+                artifacts=dict(sig.artifacts),
+            )
+
+    # Budget exhausted — honest failure.
+    sig = DoneSignal(
+        status="failed",
+        summary=(
+            f"goal '{intent}' not met after {max_iterations} iterations "
+            f"(last exit {last_exit})"
+        ),
+        artifacts={"attempts": attempts, "log": str(log_path)},
+        errors=[f"final verify exit: {last_exit}", last_tail[-200:]],
+    )
+    write_done(home, task_id, sig)
+    return PursueResult(
+        task_id=task_id, status="failed", iterations=max_iterations,
+        final_verify_exit=last_exit, log_path=log_path, done_path=done_p,
+        artifacts=dict(sig.artifacts),
+    )

package/omega/Agentik_Engine/omega_engine/rag/__init__.py

@@ -0,0 +1,21 @@
+"""Omega OS multi-RAG subsystem — five strategies behind one Protocol.
+
+`base.Retriever` is the contract every strategy honours. The Corrective RAG
+envelope (corrective.CorrectiveRetriever) wraps the chosen strategy; the
+router picks which strategy runs.
+
+See docs/ARCHITECTURE.md §7 for the full design.
+"""
+from omega_engine.rag.agentic import AgenticRetriever
+from omega_engine.rag.base import Document, RetrievalResult, Retriever
+from omega_engine.rag.corrective import CorrectiveRetriever
+from omega_engine.rag.graph import GraphRetriever
+from omega_engine.rag.hybrid import HybridRetriever
+from omega_engine.rag.multimodal import MultimodalRetriever
+from omega_engine.rag.router import RAGRouter
+
+__all__ = [
+    "Document", "RetrievalResult", "Retriever",
+    "HybridRetriever", "GraphRetriever", "AgenticRetriever",
+    "CorrectiveRetriever", "MultimodalRetriever", "RAGRouter",
+]

package/omega/Agentik_Engine/omega_engine/rag/agentic.py

@@ -0,0 +1,83 @@
+"""Agentic retriever — multi-hop retrieval steered by a provider.
+
+After every hop, the provider (role "rag-agent") looks at the current
+context and decides: keep going (return a refined `next_query`) or stop
+(`done: true`). The retriever loops up to `max_hops` and returns the
+accumulated, de-duplicated documents.
+
+This is the strategy for "decompose then dig" queries — questions where the
+first retrieval surfaces a clue, and the second clue is buried inside what
+the first one found.
+"""
+from __future__ import annotations
+
+from omega_engine.provider import AgentProvider, AgentRequest
+from omega_engine.rag.base import Document, RetrievalResult, Retriever
+
+
+class AgenticRetriever:
+    """Multi-hop on top of any underlying retriever."""
+
+    strategy = "agentic"
+
+    def __init__(
+        self,
+        inner: Retriever,
+        provider: AgentProvider,
+        *,
+        max_hops: int = 3,
+        k_per_hop: int = 4,
+    ) -> None:
+        self.inner = inner
+        self.provider = provider
+        self.max_hops = max_hops
+        self.k_per_hop = k_per_hop
+
+    def retrieve(self, query: str, k: int = 5) -> RetrievalResult:
+        seen_ids: set[str] = set()
+        accumulated: list[Document] = []
+        current = query
+        last_score = 0.0
+
+        for hop in range(self.max_hops):
+            partial = self.inner.retrieve(current, k=self.k_per_hop)
+            last_score = partial.score
+            for d in partial.documents:
+                if d.id in seen_ids:
+                    continue
+                seen_ids.add(d.id)
+                meta = dict(d.metadata)
+                meta["hop"] = hop
+                accumulated.append(Document(id=d.id, text=d.text, metadata=meta))
+
+            # Ask the provider whether to stop or refine.
+            ctx_snippets = [d.text[:200] for d in partial.documents[:3]]
+            decision = self.provider.run(AgentRequest(
+                role="rag-agent",
+                prompt=(
+                    f"Original query: {query}\n"
+                    f"Current hop: {hop}\n"
+                    f"Just-retrieved snippets:\n- " + "\n- ".join(ctx_snippets)
+                ),
+                context={
+                    "original_query": query,
+                    "current_query": current,
+                    "hop": hop,
+                    "snippets": ctx_snippets,
+                },
+            ))
+            artifacts = decision.artifacts or {}
+            if artifacts.get("done"):
+                break
+            next_q = artifacts.get("next_query")
+            if not next_q or next_q == current:
+                break
+            current = str(next_q)
+
+        # Final ranking: keep accumulation order (earlier hops first), trim to k.
+        return RetrievalResult(
+            query=query,
+            documents=accumulated[:k],
+            score=last_score,
+            strategy=self.strategy,
+        )

package/omega/Agentik_Engine/omega_engine/rag/base.py

@@ -0,0 +1,42 @@
+"""Shared contracts for every retriever — Document, RetrievalResult, Retriever.
+
+The whole RAG subsystem talks to these three types. A retriever is anything
+with `retrieve(query, k) -> RetrievalResult`. Strategies plug in behind the
+same interface, the router picks between them, and the Corrective envelope
+wraps any of them.
+"""
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Any, Protocol, runtime_checkable
+
+
+@dataclass
+class Document:
+    """A single retrievable unit — text + provenance.
+
+    `metadata` is free-form: source path, modality, chunk index, score,
+    captions for images, anything a strategy wants to surface upward.
+    """
+
+    id: str
+    text: str
+    metadata: dict[str, Any] = field(default_factory=dict)
+
+
+@dataclass
+class RetrievalResult:
+    """What every retriever returns. The router fans these up; the corrective
+    envelope grades them; the caller reads `documents`."""
+
+    query: str
+    documents: list[Document]
+    score: float = 0.0       # aggregate confidence in [0, 1]
+    strategy: str = ""       # which retriever produced this result
+
+
+@runtime_checkable
+class Retriever(Protocol):
+    """The whole RAG subsystem speaks this Protocol."""
+
+    def retrieve(self, query: str, k: int = 5) -> RetrievalResult: ...

package/omega/Agentik_Engine/omega_engine/rag/corrective.py

@@ -0,0 +1,119 @@
+"""Corrective RAG (CRAG) — the envelope every strategy wears.
+
+For each retrieval, the provider (role "rag-grader") scores every doc 0-100.
+If the average is below `threshold`, the provider (role "rag-agent") produces
+a refined query and we re-retrieve. Bounded retries — never an infinite loop.
+
+This is the user's explicit design: corrective wraps the chosen strategy.
+The router resolves WHICH retriever runs; the corrective layer ensures the
+RESULT meets a quality floor.
+"""
+from __future__ import annotations
+
+from omega_engine.provider import AgentProvider, AgentRequest
+from omega_engine.rag.base import Document, RetrievalResult, Retriever
+
+
+class CorrectiveRetriever:
+    """Grade → if low, refine query and retry. Bounded by `max_retries`."""
+
+    strategy = "corrective"
+
+    def __init__(
+        self,
+        inner: Retriever,
+        provider: AgentProvider,
+        *,
+        threshold: float = 70.0,
+        max_retries: int = 2,
+    ) -> None:
+        self.inner = inner
+        self.provider = provider
+        self.threshold = threshold
+        self.max_retries = max_retries
+
+    def retrieve(self, query: str, k: int = 5) -> RetrievalResult:
+        current = query
+        last: RetrievalResult | None = None
+
+        for attempt in range(self.max_retries + 1):
+            result = self.inner.retrieve(current, k=k)
+            last = result
+            if not result.documents:
+                break
+
+            grade_avg = self._grade(current, result.documents)
+            # Stamp the grade onto every document so the caller can see it.
+            for d in result.documents:
+                d.metadata["grader_avg"] = grade_avg
+            result.score = max(result.score, grade_avg / 100.0)
+
+            if grade_avg >= self.threshold or attempt == self.max_retries:
+                # Either good enough OR we've used up our retries.
+                inner_strategy = result.strategy
+                return RetrievalResult(
+                    query=query,
+                    documents=result.documents,
+                    score=result.score,
+                    strategy=f"corrective+{inner_strategy}",
+                )
+
+            # Below threshold AND retries remain — ask provider for a refined
+            # query and try again.
+            current = self._refine(query, current, result.documents)
+
+        # Defensive fallback — exhausted retries but never returned (e.g.
+        # zero docs from inner). Surface what we have, untouched.
+        if last is None:
+            return RetrievalResult(query=query, documents=[], score=0.0,
+                                   strategy="corrective+empty")
+        return RetrievalResult(
+            query=query,
+            documents=last.documents,
+            score=last.score,
+            strategy=f"corrective+{last.strategy}",
+        )
+
+    # ----- internals -----
+
+    def _grade(self, query: str, docs: list[Document]) -> float:
+        """Average grader score in 0-100. Bounded; missing scores → 0."""
+        result = self.provider.run(AgentRequest(
+            role="rag-grader",
+            prompt=f"Score relevance 0-100 for query: {query}",
+            context={
+                "query": query,
+                "documents": [
+                    {"id": d.id, "text": d.text[:300]} for d in docs
+                ],
+            },
+        ))
+        raw = (result.artifacts or {}).get("scores", [])
+        scores = [float(s) for s in raw if isinstance(s, (int, float))]
+        if not scores:
+            return 0.0
+        avg = sum(scores) / len(scores)
+        return max(0.0, min(100.0, avg))
+
+    def _refine(self, original: str, current: str, docs: list[Document]) -> str:
+        """Ask the provider for a refined query. Fallback: append context."""
+        result = self.provider.run(AgentRequest(
+            role="rag-agent",
+            prompt=(
+                f"Original query: {original}\n"
+                f"Current query: {current}\n"
+                "These docs scored below the relevance threshold. "
+                "Suggest a better query."
+            ),
+            context={
+                "original_query": original,
+                "current_query": current,
+                "snippets": [d.text[:200] for d in docs[:3]],
+            },
+        ))
+        next_q = (result.artifacts or {}).get("next_query")
+        if next_q and next_q != current:
+            return str(next_q)
+        # Provider had nothing useful — perturb the query so the inner
+        # retriever sees something different.
+        return f"{current} context"