@agentikos/omega-os 0.1.0

package/omega/Agentik_Engine/omega_engine/executor.py

@@ -0,0 +1,167 @@
+"""The topology executor — what makes OmegaOS run a mission.
+
+It walks a dispatcher/executor tree. A dispatcher calls its provider for a plan
+and recurses into children; a worker runs its provider, then the audit gate
+verifies it. The join barrier governs every dispatcher — it can only complete
+when all children are terminal and none failed.
+
+Every state change is an event on the bus. The reducer derives state; the
+executor never writes a state directly.
+"""
+from __future__ import annotations
+
+import uuid
+from dataclasses import dataclass
+
+from omega_engine.audit import AuditGate
+from omega_engine.barrier import ScopeStatus, scope_status
+from omega_engine.bus import EventBus
+from omega_engine.events import Event, EventType
+from omega_engine.provider import AgentRequest
+from omega_engine.reducer import reduce_task
+from omega_engine.router import ModelRouter
+from omega_engine.store import EventStore
+from omega_engine.task import Kind, Task, TaskState
+
+#: Roles that are leaf executors. Anything else is a dispatcher.
+EXECUTOR_ROLES = {"worker"}
+
+
+@dataclass
+class MissionResult:
+    mission_id: str
+    intent: str
+    root: Task
+    tasks: dict[str, Task]
+    final_state: TaskState
+
+    @property
+    def verified(self) -> bool:
+        return self.final_state is TaskState.COMPLETED
+
+
+class Executor:
+    """Runs a mission graph to completion, with verified completion throughout."""
+
+    def __init__(
+        self,
+        store: EventStore,
+        bus: EventBus,
+        router: ModelRouter,
+        audit: AuditGate,
+    ) -> None:
+        self._store = store
+        self._bus = bus
+        self._router = router
+        self._audit = audit
+        self._tasks: dict[str, Task] = {}
+
+    # -- public ---------------------------------------------------------------
+    def run_mission(self, intent: str, root_role: str = "oracle") -> MissionResult:
+        """Run a mission from a natural-language intent. Synchronous, correct."""
+        mission_id = "m-" + uuid.uuid4().hex[:8]
+        root = self._new_task(
+            kind=Kind.DISPATCHER, role=root_role,
+            spec={"intent": intent}, parent_id=None, mission_id=mission_id,
+        )
+        self._run(root, mission_id)
+        return MissionResult(
+            mission_id=mission_id, intent=intent, root=root,
+            tasks=dict(self._tasks), final_state=self._state(root.id),
+        )
+
+    # -- internals ------------------------------------------------------------
+    def _new_task(self, *, kind: Kind, role: str, spec: dict,
+                  parent_id: str | None, mission_id: str) -> Task:
+        prefix = "t-" if kind is Kind.EXECUTOR else "d-"
+        tid = prefix + uuid.uuid4().hex[:8]
+        task = Task(
+            id=tid, kind=kind, role=role,
+            spec=dict(spec, mission_id=mission_id), parent_id=parent_id,
+        )
+        self._tasks[tid] = task
+        return task
+
+    def _emit(self, task_id: str, etype: EventType, payload: dict | None = None) -> None:
+        self._bus.publish(Event(task_id=task_id, type=etype, payload=payload or {}))
+
+    def _state(self, task_id: str) -> TaskState:
+        return reduce_task(self._store.events_for(task_id))
+
+    def _run(self, task: Task, mission_id: str) -> None:
+        self._emit(task.id, EventType.CREATED,
+                   {"role": task.role, "kind": task.kind.value, "mission_id": mission_id})
+        self._emit(task.id, EventType.DISPATCHED)
+        self._emit(task.id, EventType.STARTED)
+        if task.kind is Kind.EXECUTOR:
+            self._run_worker(task)
+        else:
+            self._run_dispatcher(task, mission_id)
+        task.state = self._state(task.id)
+
+    def _run_dispatcher(self, task: Task, mission_id: str) -> None:
+        provider = self._router.resolve(task.role)
+        prompt = task.spec.get("intent") or task.spec.get("task") or task.role
+        result = provider.run(
+            AgentRequest(role=task.role, prompt=str(prompt), context=task.spec)
+        )
+        children: list[Task] = []
+        for item in result.plan:
+            child_role = item.get("role", "worker")
+            child_kind = (
+                Kind.EXECUTOR if child_role in EXECUTOR_ROLES else Kind.DISPATCHER
+            )
+            child = self._new_task(
+                kind=child_kind, role=child_role,
+                spec=item.get("spec", {}), parent_id=task.id, mission_id=mission_id,
+            )
+            self._run(child, mission_id)
+            children.append(child)
+
+        status = scope_status([self._state(c.id) for c in children])
+        if status is ScopeStatus.JOINABLE:
+            # the barrier resolved — the dispatcher may now close
+            self._emit(task.id, EventType.SCOPE_JOINABLE, {"children": len(children)})
+            self._emit(task.id, EventType.CLAIMED_DONE)
+            self._emit(task.id, EventType.VERIFYING)
+            self._emit(task.id, EventType.VERIFIED, {"reason": "all children verified"})
+            self._emit(task.id, EventType.COMPLETED)
+        else:
+            # PARTIAL — a child failed. on_partial = fail_up (children already
+            # retried within their own budget). Honest partial failure.
+            failed = [c.id for c in children
+                      if self._state(c.id) is TaskState.FAILED]
+            self._emit(task.id, EventType.FAILED,
+                       {"reason": "partial scope", "failed_children": failed})
+
+    def _run_worker(self, task: Task) -> None:
+        provider = self._router.resolve(task.role)
+        for attempt in range(task.budget.max_iterations):
+            result = provider.run(AgentRequest(
+                role=task.role,
+                prompt=str(task.spec.get("task", task.role)),
+                context=task.spec,
+            ))
+            self._emit(task.id, EventType.CLAIMED_DONE, {"attempt": attempt + 1})
+            self._emit(task.id, EventType.VERIFYING)
+            verdict = self._audit.verify({
+                "artifacts": result.artifacts,
+                "runtime_cmd": task.spec.get("verify_cmd"),
+                "role": task.role,
+                "changed": result.artifacts.get("files", []),
+                "path": str(task.spec.get("path", ".")),
+            })
+            if verdict.verified:
+                self._emit(task.id, EventType.VERIFIED, {
+                    "score": verdict.score,
+                    "findings": [f.audit for f in verdict.findings],
+                })
+                self._emit(task.id, EventType.COMPLETED)
+                return
+            self._emit(task.id, EventType.REJECTED,
+                       {"score": verdict.score, "attempt": attempt + 1})
+            if attempt + 1 < task.budget.max_iterations:
+                self._emit(task.id, EventType.DISPATCHED, {"retry": attempt + 2})
+                self._emit(task.id, EventType.STARTED)
+        # budget exhausted — honest failure, the deadman clause terminates it
+        self._emit(task.id, EventType.FAILED, {"reason": "audit budget exhausted"})

package/omega/Agentik_Engine/omega_engine/mission.py

@@ -0,0 +1,145 @@
+"""Mission coordinator — the entry point that ties the runtime together.
+
+`run_mission()` executes a mission, tracks progress live to a Telegram topic
+(a progress bar that updates in place, throttled to respect flood control), and
+ALWAYS produces the Oracle's whitepaper PDF report — delivered into the topic.
+
+Telegram is best-effort: a delivery hiccup never fails a mission that ran fine.
+"""
+from __future__ import annotations
+
+import os
+import time
+from dataclasses import dataclass
+from pathlib import Path
+
+from omega_engine.audit import AuditGate
+from omega_engine.bus import EventBus
+from omega_engine.executor import Executor, MissionResult
+from omega_engine.progress import ProgressTracker
+from omega_engine.provider import ClaudeProvider, MockProvider
+from omega_engine.report import generate_mission_report
+from omega_engine.router import ModelRouter
+from omega_engine.store import SQLiteStore
+
+#: minimum seconds between live progress edits — Telegram flood control
+_EDIT_THROTTLE_S = 3.0
+
+
+def _omega_home(explicit: str | Path | None = None) -> Path:
+    return Path(explicit or os.environ.get("OMEGA_HOME", str(Path.home() / "Omega")))
+
+
+def build_router() -> ModelRouter:
+    """Real Claude when a key is present, else the deterministic MockProvider —
+    so `omega run` always works, with or without credentials."""
+    use_claude = (
+        os.environ.get("ANTHROPIC_API_KEY")
+        and os.environ.get("OMEGA_PROVIDER", "") != "mock"
+    )
+    if use_claude:
+        try:
+            import anthropic  # noqa: F401
+            return ModelRouter.single(ClaudeProvider())
+        except ImportError:
+            pass
+    return ModelRouter.single(MockProvider())
+
+
+@dataclass
+class MissionOutcome:
+    result: MissionResult
+    report_pdf: Path | None
+    progress_pct: int
+
+
+def run_mission(
+    intent: str,
+    *,
+    omega_home: str | Path | None = None,
+    topic_id: int | None = None,
+    telegram: object | None = None,
+    report_dir: str | Path | None = None,
+) -> MissionOutcome:
+    """Run a mission end-to-end. Always emits the Oracle's PDF report."""
+    home = _omega_home(omega_home)
+    store = SQLiteStore(home / "Agentik_Runtime" / "eventlog" / "omega.db")
+    bus = EventBus(store)
+    tracker = ProgressTracker()
+    bus.subscribe(tracker.on_event)
+
+    # live Telegram progress — a message that edits itself as work advances,
+    # throttled so a fast mission cannot trip flood control.
+    progress_msg_id: int | None = None
+    last_edit = [0.0]
+    if telegram is not None and topic_id is not None:
+        try:
+            progress_msg_id = telegram.post(  # type: ignore[attr-defined]
+                topic_id, "Omega OS - mission starting...")
+        except Exception as exc:  # noqa: BLE001
+            print(f"[mission] telegram post failed: {exc}")
+
+        def _live(event) -> None:
+            if event.type.value not in ("task.verified", "task.failed"):
+                return
+            if progress_msg_id is None:
+                return
+            now = time.time()
+            if now - last_edit[0] < _EDIT_THROTTLE_S:
+                return
+            last_edit[0] = now
+            missions = tracker.all()
+            if not missions:
+                return
+            try:
+                telegram.edit(  # type: ignore[attr-defined]
+                    progress_msg_id,
+                    missions[0].render(title="Omega OS - mission in progress"))
+            except Exception:  # noqa: BLE001 — progress is best-effort
+                pass
+
+        bus.subscribe(_live)
+
+    # the verification gate: the full Quality Arsenal when audit definitions are
+    # deployed (Agentik_SSOT/audits/), else the simple runtime gate.
+    router = build_router()
+    audits_dir = home / "Agentik_SSOT" / "audits"
+    if audits_dir.is_dir() and any(audits_dir.glob("*.yaml")):
+        from omega_engine.audit_arsenal import ArsenalGate, AuditRegistry
+        gate: object = ArsenalGate(AuditRegistry.load(audits_dir), router)
+    else:
+        gate = AuditGate()
+    executor = Executor(store, bus, router, gate)
+    result = executor.run_mission(intent)
+
+    # the Oracle ALWAYS produces a report
+    rdir = Path(report_dir or (home / "Agentik_Runtime" / "verdicts"))
+    report_pdf: Path | None
+    try:
+        report_pdf = generate_mission_report(result, store, rdir)
+    except Exception as exc:  # noqa: BLE001
+        report_pdf = None
+        print(f"[mission] report generation failed: {exc}")
+
+    prog = tracker.progress(result.mission_id)
+    pct = prog.pct if prog else 0
+
+    if telegram is not None and topic_id is not None:
+        verdict = "VERIFIED" if result.verified else "PARTIAL / FAILED"
+        if progress_msg_id is not None and prog is not None:
+            try:
+                telegram.edit(  # type: ignore[attr-defined]
+                    progress_msg_id,
+                    prog.render(title=f"{verdict} - mission complete"))
+            except Exception as exc:  # noqa: BLE001
+                print(f"[mission] final progress edit failed: {exc}")
+        if report_pdf is not None:
+            try:
+                telegram.send_document(  # type: ignore[attr-defined]
+                    topic_id, report_pdf,
+                    caption=f"{verdict} - mission report - {intent[:80]}")
+            except Exception as exc:  # noqa: BLE001
+                print(f"[mission] report delivery failed (report is on disk): {exc}")
+
+    store.close()
+    return MissionOutcome(result=result, report_pdf=report_pdf, progress_pct=pct)

package/omega/Agentik_Engine/omega_engine/progress.py

@@ -0,0 +1,75 @@
+"""Live progress tracking — turn the event stream into a progress bar.
+
+`ProgressTracker` is an EventBus subscriber. It keeps one `MissionProgress` per
+mission, derived purely from events — so progress, like completion, is never
+self-declared.
+"""
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+from omega_engine.events import Event, EventType
+
+
+@dataclass
+class MissionProgress:
+    mission_id: str
+    total_tasks: int = 0
+    verified: int = 0
+    failed: int = 0
+    last_event: str = ""
+
+    @property
+    def done(self) -> int:
+        return self.verified + self.failed
+
+    @property
+    def pct(self) -> int:
+        return round(100 * self.done / self.total_tasks) if self.total_tasks else 0
+
+    def bar(self, width: int = 20) -> str:
+        filled = round(width * self.pct / 100)
+        return "█" * filled + "░" * (width - filled)
+
+    def render(self, title: str = "") -> str:
+        """A Telegram-ready progress block."""
+        head = f"{title}\n" if title else ""
+        return (
+            f"{head}{self.bar()}  {self.pct}%\n"
+            f"{self.verified} verified · {self.failed} failed "
+            f"· {self.total_tasks} tasks\n"
+            f"last: {self.last_event}"
+        )
+
+
+class ProgressTracker:
+    """Subscribe `.on_event` to an EventBus; read `.progress(mission_id)`."""
+
+    def __init__(self) -> None:
+        self._missions: dict[str, MissionProgress] = {}
+        self._task_mission: dict[str, str] = {}
+
+    def on_event(self, event: Event) -> None:
+        if event.type is EventType.CREATED:
+            mid = str(event.payload.get("mission_id", ""))
+            if mid:
+                self._task_mission[event.task_id] = mid
+                prog = self._missions.setdefault(mid, MissionProgress(mid))
+                prog.total_tasks += 1
+
+        mid = self._task_mission.get(event.task_id)
+        if not mid:
+            return
+        prog = self._missions[mid]
+        prog.last_event = f"{event.type.value} {event.task_id}"
+        if event.type is EventType.VERIFIED:
+            prog.verified += 1
+        elif event.type is EventType.FAILED:
+            prog.failed += 1
+
+    def progress(self, mission_id: str) -> MissionProgress | None:
+        return self._missions.get(mission_id)
+
+    def all(self) -> list[MissionProgress]:
+        """Every mission's progress — used by the live Telegram reporter."""
+        return list(self._missions.values())

package/omega/Agentik_Engine/omega_engine/project.py

@@ -0,0 +1,92 @@
+"""Project creation — structure, registry entry, and a bound Telegram topic.
+
+Creating a project builds its folder under Agentik_Coding/projects/, registers
+it in the canonical project registry (the project<->topic map that routes
+Telegram messages), and — if a Telegram bridge is given — creates its forum
+topic.
+"""
+from __future__ import annotations
+
+import json
+import os
+import re
+import time
+from dataclasses import asdict, dataclass
+from pathlib import Path
+
+
+def slugify(name: str) -> str:
+    slug = re.sub(r"[^a-z0-9]+", "-", name.lower()).strip("-")
+    return slug or "project"
+
+
+@dataclass
+class Project:
+    name: str
+    slug: str
+    path: str
+    topic_id: int | None = None
+    created_at: str = ""
+
+
+def _omega_home(explicit: str | Path | None = None) -> Path:
+    return Path(explicit or os.environ.get("OMEGA_HOME", str(Path.home() / "Omega")))
+
+
+def _registry_file(home: Path) -> Path:
+    return home / "Agentik_Coding" / "projects.json"
+
+
+def load_projects(omega_home: str | Path | None = None) -> list[Project]:
+    """The canonical project registry — the project <-> Telegram-topic map."""
+    fpath = _registry_file(_omega_home(omega_home))
+    if not fpath_exists(fpath):
+        return []
+    rows = json.loads(fpath.read_text() or "[]")
+    return [Project(**row) for row in rows]
+
+
+def fpath_exists(p: Path) -> bool:
+    return p.exists()
+
+
+def _save(home: Path, projects: list[Project]) -> None:
+    fpath = _registry_file(home)
+    fpath.parent.mkdir(parents=True, exist_ok=True)
+    fpath.write_text(
+        json.dumps([asdict(p) for p in projects], indent=2, ensure_ascii=False)
+    )
+
+
+def create_project(name: str, omega_home: str | Path | None = None,
+                    telegram: object | None = None) -> Project:
+    """Create a project: folder + README + registry entry + Telegram topic.
+
+    `telegram` is an optional TelegramBridge — when given, a forum topic is
+    created and bound to the project.
+    """
+    home = _omega_home(omega_home)
+    slug = slugify(name)
+    projects = load_projects(home)
+    if any(p.slug == slug for p in projects):
+        raise ValueError(f"project '{slug}' already exists")
+
+    path = home / "Agentik_Coding" / "projects" / slug
+    path.mkdir(parents=True, exist_ok=True)
+    (path / "README.md").write_text(
+        f"# {name}\n\n"
+        f"Project managed by Omega OS. Missions addressed to this project "
+        f"route to its bound Telegram topic.\n"
+    )
+
+    topic_id: int | None = None
+    if telegram is not None:
+        topic_id = telegram.create_topic(name)  # type: ignore[attr-defined]
+
+    project = Project(
+        name=name, slug=slug, path=str(path), topic_id=topic_id,
+        created_at=time.strftime("%Y-%m-%dT%H:%M:%S"),
+    )
+    projects.append(project)
+    _save(home, projects)
+    return project

package/omega/Agentik_Engine/omega_engine/provider.py

@@ -0,0 +1,139 @@
+"""The provider abstraction — one contract, any LLM.
+
+The executor talks only to `AgentProvider`. `MockProvider` makes the whole
+orchestration testable with no network. `ClaudeProvider` is the real adapter.
+"""
+from __future__ import annotations
+
+import json
+import re
+from dataclasses import dataclass, field
+from typing import Any, Protocol, runtime_checkable
+
+
+@dataclass
+class AgentRequest:
+    role: str                                   # "aisb" | "oracle" | "worker" | ...
+    prompt: str
+    context: dict[str, Any] = field(default_factory=dict)
+
+
+@dataclass
+class AgentResult:
+    text: str
+    claimed_done: bool = False
+    artifacts: dict[str, Any] = field(default_factory=dict)
+    plan: list[dict[str, Any]] = field(default_factory=list)  # dispatcher roles only
+    usage: dict[str, int] = field(default_factory=dict)
+
+
+@runtime_checkable
+class AgentProvider(Protocol):
+    """Every LLM sits behind this. ~200-400 lines per real adapter."""
+
+    id: str
+
+    def run(self, req: AgentRequest) -> AgentResult: ...
+
+
+class MockProvider:
+    """Deterministic provider — makes the executor fully testable with no API.
+
+    Dispatcher roles (oracle/manager) return a `plan`; workers return artifacts
+    and `claimed_done`; the verifier returns a passing score.
+    """
+
+    id = "mock"
+
+    def __init__(self, plan_size: int = 2) -> None:
+        self._plan_size = plan_size
+
+    def run(self, req: AgentRequest) -> AgentResult:
+        role = req.role
+        if role in ("oracle", "manager", "aisb"):
+            plan = [
+                {"role": "worker",
+                 "spec": {"task": f"subtask {i + 1}", "verify_cmd": "true"}}
+                for i in range(self._plan_size)
+            ]
+            return AgentResult(text=f"planned {len(plan)} subtasks",
+                               claimed_done=True, plan=plan)
+        if role == "worker":
+            task = req.context.get("task", "task")
+            return AgentResult(
+                text=f"completed: {task}",
+                claimed_done=True,
+                artifacts={"summary": f"completed: {task}", "files": ["mock_change.py"]},
+                usage={"input_tokens": 100, "output_tokens": 200},
+            )
+        if role in ("verifier", "audit"):
+            # a structured forensic verdict — what the Quality Arsenal expects
+            return AgentResult(
+                text="audit pass", claimed_done=True,
+                artifacts={"verdict": {
+                    "score": 95, "verified": True, "confidence": "high",
+                    "summary": "mock forensic audit — no falsifiable claims found",
+                    "findings": [], "fix_plan": [],
+                }})
+        return AgentResult(text="ok", claimed_done=True)
+
+
+class ClaudeProvider:
+    """Real provider — wraps the Anthropic SDK.
+
+    Needs `ANTHROPIC_API_KEY` in the environment (or passed) and the `anthropic`
+    package: `pip install omega-engine[providers]`. The credential resolves
+    through the Account pool (Agentik_Providers/claude/accounts.yaml).
+    """
+
+    id = "claude"
+
+    def __init__(self, model: str = "claude-opus-4-7", api_key: str | None = None) -> None:
+        self._model = model
+        self._api_key = api_key
+
+    def run(self, req: AgentRequest) -> AgentResult:
+        try:
+            import anthropic
+        except ImportError as exc:  # pragma: no cover - depends on optional extra
+            raise RuntimeError(
+                "ClaudeProvider needs the `anthropic` package — "
+                "pip install omega-engine[providers]"
+            ) 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}],
+        )
+        text = "".join(
+            b.text for b in msg.content if getattr(b, "type", "") == "text"
+        )
+        return AgentResult(
+            text=text,
+            claimed_done=True,
+            plan=_extract_plan(text) if req.role in ("oracle", "manager", "aisb") else [],
+            usage={
+                "input_tokens": msg.usage.input_tokens,
+                "output_tokens": msg.usage.output_tokens,
+            },
+        )
+
+
+def _extract_plan(text: str) -> list[dict[str, Any]]:
+    """Pull a JSON subtask array out of an LLM response. Empty list if none."""
+    match = re.search(r"\[.*\]", text, re.DOTALL)
+    if not match:
+        return []
+    try:
+        data = json.loads(match.group(0))
+        return data if isinstance(data, list) else []
+    except json.JSONDecodeError:
+        return []