@agentikos/omega-os 0.1.0 → 0.2.0

package/omega/Agentik_Engine/omega_engine/daemons/engine.py

@@ -0,0 +1,187 @@
+"""The engine daemon — keeps the event store alive 24/7.
+
+What it actually does:
+
+* opens ``$OMEGA_HOME/Agentik_Runtime/eventlog/omega.db`` (WAL-mode SQLite)
+* periodically appends a ``system.heartbeat`` event so the store always has a
+  fresh "this engine is alive" anchor
+* exposes a small stdlib HTTP API on ``127.0.0.1:OMEGA_ENGINE_PORT`` so the
+  other daemons (telegram, autonomous) can ask the engine to run a mission
+  inside *one* process tree (avoids each daemon spinning its own duplicate
+  executor stack)
+* exits cleanly on SIGTERM / SIGINT (systemd `Restart=always` handles the rest)
+"""
+from __future__ import annotations
+
+import json
+import logging
+import os
+import signal
+import threading
+import time
+from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
+from pathlib import Path
+
+from omega_engine.bus import EventBus
+from omega_engine.events import Event, EventType
+from omega_engine.store import SQLiteStore
+
+logger = logging.getLogger("omega.daemon.engine")
+
+# the heartbeat event lives outside the task FSM, so we reuse the HEARTBEAT
+# event type but with a system-level task id.
+_SYSTEM_TASK_ID = "system.engine"
+_HEARTBEAT_PERIOD_S = 60.0
+
+
+def _omega_home() -> Path:
+    return Path(os.environ.get("OMEGA_HOME", str(Path.home() / "Omega")))
+
+
+def _store_path(home: Path) -> Path:
+    return home / "Agentik_Runtime" / "eventlog" / "omega.db"
+
+
+# ─────────────────────────────────────────────────────────────────────────────
+# HTTP API — local-only mission dispatch
+# ─────────────────────────────────────────────────────────────────────────────
+
+class _EngineHandler(BaseHTTPRequestHandler):
+    """A tiny REST-ish surface. JSON in/out. Loopback only.
+
+    Endpoints:
+
+    * ``GET  /health``          -- liveness
+    * ``POST /mission``         -- body: ``{"intent": "..."}``; runs a mission
+                                   synchronously and returns the result. Used
+                                   by the telegram daemon for project-bound
+                                   topics.
+    """
+
+    # silence stock access log → use our logger
+    def log_message(self, fmt: str, *args) -> None:  # noqa: A003
+        logger.debug("http: " + fmt, *args)
+
+    def _reply(self, status: int, payload: dict) -> None:
+        body = json.dumps(payload).encode()
+        self.send_response(status)
+        self.send_header("Content-Type", "application/json")
+        self.send_header("Content-Length", str(len(body)))
+        self.end_headers()
+        self.wfile.write(body)
+
+    def do_GET(self) -> None:  # noqa: N802 — required by BaseHTTPRequestHandler
+        if self.path == "/health":
+            self._reply(200, {"ok": True, "ts": time.time()})
+            return
+        self._reply(404, {"error": "not found"})
+
+    def do_POST(self) -> None:  # noqa: N802
+        if self.path != "/mission":
+            self._reply(404, {"error": "not found"})
+            return
+        length = int(self.headers.get("Content-Length", "0"))
+        raw = self.rfile.read(length).decode() if length else "{}"
+        try:
+            body = json.loads(raw) if raw else {}
+        except json.JSONDecodeError:
+            self._reply(400, {"error": "invalid json"})
+            return
+        intent = body.get("intent")
+        topic_id = body.get("topic_id")
+        if not intent:
+            self._reply(400, {"error": "missing intent"})
+            return
+        try:
+            from omega_engine.mission import run_mission
+            outcome = run_mission(
+                intent=intent,
+                topic_id=topic_id,
+                telegram=None,  # the telegram daemon supplies its own bridge
+            )
+            self._reply(200, {
+                "mission_id": outcome.result.mission_id,
+                "verified": outcome.result.verified,
+                "final_state": outcome.result.final_state.value,
+                "progress_pct": outcome.progress_pct,
+                "report_pdf": (
+                    str(outcome.report_pdf) if outcome.report_pdf else None
+                ),
+            })
+        except Exception as exc:  # noqa: BLE001
+            logger.exception("engine HTTP: mission failed")
+            self._reply(500, {"error": str(exc)})
+
+
+def _serve_http(port: int, stop: threading.Event) -> None:
+    """Run the HTTP API until ``stop`` is set."""
+    httpd = ThreadingHTTPServer(("127.0.0.1", port), _EngineHandler)
+    httpd.timeout = 1.0
+    logger.info("engine HTTP API on 127.0.0.1:%d", port)
+    while not stop.is_set():
+        httpd.handle_request()
+    httpd.server_close()
+
+
+# ─────────────────────────────────────────────────────────────────────────────
+# Main loop
+# ─────────────────────────────────────────────────────────────────────────────
+
+def main() -> int:
+    logging.basicConfig(
+        level=os.environ.get("OMEGA_LOG_LEVEL", "INFO"),
+        format="%(asctime)s %(name)s %(levelname)s %(message)s",
+    )
+    home = _omega_home()
+    db_path = _store_path(home)
+    db_path.parent.mkdir(parents=True, exist_ok=True)
+
+    store = SQLiteStore(db_path)
+    bus = EventBus(store)
+    logger.info("engine daemon online — store=%s", db_path)
+
+    stop = threading.Event()
+    signal.signal(signal.SIGTERM, lambda *_: stop.set())
+    signal.signal(signal.SIGINT, lambda *_: stop.set())
+
+    port = int(os.environ.get("OMEGA_ENGINE_PORT", "8731"))
+    http_thread = threading.Thread(
+        target=_serve_http, args=(port, stop), daemon=True, name="omega-engine-http",
+    )
+    http_thread.start()
+
+    # first heartbeat at startup so `omega status` immediately shows the engine
+    bus.publish(Event(
+        task_id=_SYSTEM_TASK_ID,
+        type=EventType.HEARTBEAT,
+        payload={"daemon": "engine", "event": "start"},
+    ))
+
+    last_beat = time.time()
+    try:
+        while not stop.is_set():
+            now = time.time()
+            if now - last_beat >= _HEARTBEAT_PERIOD_S:
+                try:
+                    bus.publish(Event(
+                        task_id=_SYSTEM_TASK_ID,
+                        type=EventType.HEARTBEAT,
+                        payload={"daemon": "engine", "ts": now},
+                    ))
+                except Exception:  # noqa: BLE001 — never die on a heartbeat
+                    logger.exception("engine daemon: heartbeat publish failed")
+                last_beat = now
+            stop.wait(1.0)
+    finally:
+        bus.publish(Event(
+            task_id=_SYSTEM_TASK_ID,
+            type=EventType.HEARTBEAT,
+            payload={"daemon": "engine", "event": "stop"},
+        ))
+        store.close()
+        logger.info("engine daemon stopped")
+    return 0
+
+
+if __name__ == "__main__":  # pragma: no cover
+    raise SystemExit(main())

package/omega/Agentik_Engine/omega_engine/daemons/telegram.py

@@ -0,0 +1,231 @@
+"""The Telegram daemon — listens to the bot, routes messages.
+
+Long-polls ``getUpdates`` (HTTP via ``curl``, the same pattern
+:class:`omega_engine.telegram.TelegramBridge` uses) and routes every inbound
+message:
+
+1. If the message is in a forum topic that an autonomous charter is bound to
+   → :meth:`AutonomousSupervisor.on_channel_message` (the agent handles it).
+2. Else, if the topic is a *project* topic registered in
+   ``Agentik_Coding/projects.json`` → :func:`run_mission` with that topic id.
+3. Else → log and ignore.
+
+The daemon shares no in-process state with the engine daemon — it talks to it
+through the engine's HTTP API when a mission has to run (avoids two parallel
+SQLite writers). Telegram is best-effort: a network blip never kills the loop.
+
+On SIGTERM/SIGINT the daemon stops cleanly.
+"""
+from __future__ import annotations
+
+import json
+import logging
+import os
+import signal
+import subprocess
+import time
+from pathlib import Path
+from typing import Any
+
+from omega_engine.autonomous import build_supervisor_from_home
+
+logger = logging.getLogger("omega.daemon.telegram")
+
+_POLL_TIMEOUT_S = 25            # Telegram long-poll
+_BACKOFF_S = 5.0                # on network / API errors
+_API = "https://api.telegram.org"
+
+
+def _omega_home() -> Path:
+    return Path(os.environ.get("OMEGA_HOME", str(Path.home() / "Omega")))
+
+
+# ─────────────────────────────────────────────────────────────────────────────
+# Telegram bot — getUpdates loop (curl-based, no extra deps)
+# ─────────────────────────────────────────────────────────────────────────────
+
+def _read_token(home: Path) -> str:
+    env_file = home / "Agentik_Extra" / "etc" / "secrets" / "telegram.env"
+    if not env_file.exists():
+        raise RuntimeError(f"telegram secret not found: {env_file}")
+    for line in env_file.read_text().splitlines():
+        line = line.strip()
+        if line.startswith("TELEGRAM_TOKEN="):
+            return line.split("=", 1)[1].strip()
+    raise RuntimeError("TELEGRAM_TOKEN missing from the vault")
+
+
+def _curl_json(url: str, *, timeout: int) -> dict[str, Any]:
+    """Issue one curl call; return the parsed JSON or ``{}`` on hard failure."""
+    cmd = ["curl", "-s", "--max-time", str(timeout + 5), url]
+    proc = subprocess.run(cmd, capture_output=True, text=True, timeout=timeout + 10)
+    if proc.returncode != 0:
+        raise RuntimeError(f"curl exit {proc.returncode}: {proc.stderr[:200]}")
+    try:
+        return json.loads(proc.stdout or "{}")
+    except json.JSONDecodeError as exc:
+        raise RuntimeError(f"bad JSON: {proc.stdout[:200]}") from exc
+
+
+def _get_updates(token: str, offset: int) -> list[dict[str, Any]]:
+    """One long-poll cycle. Returns the new updates (possibly empty)."""
+    url = (f"{_API}/bot{token}/getUpdates?"
+           f"timeout={_POLL_TIMEOUT_S}&offset={offset}")
+    data = _curl_json(url, timeout=_POLL_TIMEOUT_S)
+    if not data.get("ok"):
+        raise RuntimeError(f"getUpdates: {data.get('description', 'unknown')}")
+    return data.get("result", []) or []
+
+
+# ─────────────────────────────────────────────────────────────────────────────
+# Routing
+# ─────────────────────────────────────────────────────────────────────────────
+
+def _project_topic_map(home: Path) -> dict[int, str]:
+    """Read the project registry. Returns ``{topic_id: slug}``.
+
+    A project owns a forum topic; messages in that topic are addressed to the
+    project (the missions the user types there run against it).
+    """
+    registry = home / "Agentik_Coding" / "projects.json"
+    if not registry.exists():
+        return {}
+    try:
+        rows = json.loads(registry.read_text() or "[]")
+    except json.JSONDecodeError:
+        return {}
+    out: dict[int, str] = {}
+    for row in rows:
+        topic = row.get("topic_id")
+        slug = row.get("slug")
+        if topic is not None and slug:
+            out[int(topic)] = str(slug)
+    return out
+
+
+def _extract_message_fields(update: dict[str, Any]) -> tuple[int | None, int | None, str | None]:
+    """Pull (topic_id, message_id, text) from an update — None if not relevant."""
+    msg = update.get("message") or update.get("edited_message") or {}
+    text = msg.get("text")
+    if not text:
+        return None, None, None
+    topic_id = msg.get("message_thread_id")
+    message_id = msg.get("message_id")
+    return topic_id, message_id, text
+
+
+def _route_one(
+    *,
+    topic_id: int,
+    text: str,
+    supervisor,
+    project_map: dict[int, str],
+    home: Path,
+    telegram_bridge,
+) -> str:
+    """Route one inbound message; return a short tag for the log."""
+    # 1. autonomous-agent channel match wins
+    fired = supervisor.on_channel_message(topic_id, text)
+    if fired:
+        return f"autonomous:{','.join(fired)}"
+    # 2. project topic → run_mission
+    slug = project_map.get(topic_id)
+    if slug:
+        # we use run_mission directly here (in-process); the engine daemon's
+        # HTTP API exists for *cross-process* dispatch, not for the daemon that
+        # already lives in the right process.
+        from omega_engine.mission import run_mission
+        try:
+            run_mission(
+                intent=text,
+                omega_home=home,
+                topic_id=topic_id,
+                telegram=telegram_bridge,
+            )
+        except Exception:  # noqa: BLE001
+            logger.exception("telegram daemon: project mission failed")
+            return f"project:{slug}:error"
+        return f"project:{slug}"
+    return "ignored"
+
+
+# ─────────────────────────────────────────────────────────────────────────────
+# Main loop
+# ─────────────────────────────────────────────────────────────────────────────
+
+def main() -> int:
+    logging.basicConfig(
+        level=os.environ.get("OMEGA_LOG_LEVEL", "INFO"),
+        format="%(asctime)s %(name)s %(levelname)s %(message)s",
+    )
+    home = _omega_home()
+    try:
+        token = _read_token(home)
+    except RuntimeError as exc:
+        logger.error("telegram daemon: %s", exc)
+        return 1
+
+    # the supervisor stays loaded (charters discovered at startup); we DO NOT
+    # call .run() — we just use it as a router. Channel-trigger firings will
+    # be dispatched via its callable runner (defaults to run_mission).
+    supervisor = build_supervisor_from_home(home)
+    project_map = _project_topic_map(home)
+    logger.info("telegram daemon: %d charter(s) bound, %d project(s) mapped",
+                len(supervisor.charters()), len(project_map))
+
+    # an outbound bridge for project missions (progress edits + PDF delivery)
+    telegram_bridge = None
+    try:
+        from omega_engine.telegram import TelegramBridge
+        telegram_bridge = TelegramBridge.from_vault(home)
+    except Exception as exc:  # noqa: BLE001
+        logger.warning("telegram daemon: outbound bridge disabled (%s)", exc)
+
+    stop = [False]
+    signal.signal(signal.SIGTERM, lambda *_: stop.__setitem__(0, True))
+    signal.signal(signal.SIGINT, lambda *_: stop.__setitem__(0, True))
+
+    offset = 0  # only positive update_ids; 0 = "give me everything"
+    backoff = 0.0
+    while not stop[0]:
+        if backoff > 0:
+            # use a *short* sleep loop so SIGTERM still wakes us promptly
+            slept = 0.0
+            while slept < backoff and not stop[0]:
+                time.sleep(min(1.0, backoff - slept))
+                slept += 1.0
+            backoff = 0.0
+            if stop[0]:
+                break
+
+        try:
+            updates = _get_updates(token, offset)
+        except Exception as exc:  # noqa: BLE001
+            logger.warning("telegram daemon: poll failed (%s) — backing off", exc)
+            backoff = _BACKOFF_S
+            continue
+
+        for update in updates:
+            offset = max(offset, int(update.get("update_id", 0)) + 1)
+            topic_id, _message_id, text = _extract_message_fields(update)
+            if topic_id is None or not text:
+                continue
+            # refresh the project map periodically so newly created projects
+            # become routable without restarting the daemon
+            project_map = _project_topic_map(home)
+            try:
+                tag = _route_one(
+                    topic_id=topic_id, text=text, supervisor=supervisor,
+                    project_map=project_map, home=home,
+                    telegram_bridge=telegram_bridge,
+                )
+                logger.info("telegram in: topic=%s text=%r -> %s",
+                            topic_id, text[:80], tag)
+            except Exception:  # noqa: BLE001
+                logger.exception("telegram daemon: routing failed")
+    logger.info("telegram daemon stopped")
+    return 0
+
+
+if __name__ == "__main__":  # pragma: no cover
+    raise SystemExit(main())

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

@@ -0,0 +1,51 @@
+"""The educators — the self-improving layer of OmegaOS.
+
+Eight generators that produce SSOT artifacts under the same quality gate that
+guards code. The framework lives in ``base``; each domain has its own focused
+module. None of them write to the SSOT directly — every proposal goes through
+``StagingPipeline``.
+
+Usage::
+
+    from omega_engine.educators import EducatorRegistry, StagingPipeline
+    from omega_engine.provider import MockProvider
+
+    registry = EducatorRegistry.default()
+    staging = StagingPipeline("/path/to/Agentik_Extra/staging/promotion")
+    proposal = registry.get("prompt").generate(
+        intent="oracle dispatches to a fresh worker",
+        context={"source": "oracle", "target": "worker"},
+        provider=MockProvider(),
+    )
+    record = staging.stage(proposal)
+"""
+from omega_engine.educators.artifact import ArtifactEducator
+from omega_engine.educators.automation import AutomationEducator
+from omega_engine.educators.base import (
+    Artifact,
+    Educator,
+    EducatorProposal,
+    EducatorRegistry,
+    StagingPipeline,
+    StagingRecord,
+    build_education_prompt,
+    parse_proposal,
+    run_education,
+)
+from omega_engine.educators.claudecode import ClaudecodeEducator
+from omega_engine.educators.connection import ConnectionEducator
+from omega_engine.educators.coworker import CoworkerEducator
+from omega_engine.educators.loop import LoopEducator
+from omega_engine.educators.prompt import PromptEducator
+from omega_engine.educators.skill import SkillEducator
+
+__all__ = [
+    # framework
+    "Artifact", "Educator", "EducatorProposal", "EducatorRegistry",
+    "StagingPipeline", "StagingRecord",
+    "build_education_prompt", "parse_proposal", "run_education",
+    # the eight
+    "PromptEducator", "ArtifactEducator", "SkillEducator", "CoworkerEducator",
+    "ConnectionEducator", "AutomationEducator", "ClaudecodeEducator",
+    "LoopEducator",
+]

package/omega/Agentik_Engine/omega_engine/educators/artifact.py

@@ -0,0 +1,65 @@
+"""`artifact-educator` — generates templates for deliverables.
+
+The signature: produces a reusable template for a class of artifacts that
+workers ship at the end of a mission — mission reports, audit reports, doc
+pages, component scaffolds, PR descriptions, ADRs.
+
+Target SSOT path: ``Agentik_SSOT/templates/<kind>.md``.
+"""
+from __future__ import annotations
+
+from typing import Any
+
+from omega_engine.educators.base import EducatorProposal, run_education
+from omega_engine.provider import AgentProvider
+
+_INSTRUCTIONS = """\
+Produce ONE artifact TEMPLATE — a reusable scaffold that workers fill in when
+they ship work of this kind. The template MUST:
+
+  1. Open with a one-line statement of what THIS template is for.
+  2. Define the required sections (use H2 headings) in fill-in order — every
+     section title MUST be the noun-phrase the worker uses ("Summary",
+     "Changes", "Tests", "Verify Command", "Screenshots"), never a generic
+     "details" or "info".
+  3. Mark required-vs-optional sections explicitly (e.g. "[required]").
+  4. Provide ONE-LINE placeholders in each section, in the form
+     `<short prompt to the worker, in imperative voice>` — never lorem ipsum.
+  5. End with a quality checklist (3-7 boxes) the worker self-checks before
+     declaring done — the items must be falsifiable, not feel-good.
+
+The template MUST NOT:
+  - assume the worker has unbounded time or tokens (sections must be terse)
+  - omit a verification section (every deliverable shows HOW it was verified)
+  - duplicate work that other templates already handle — state the boundary
+    if there is overlap.
+
+Format the artifact as Markdown.
+"""
+
+
+class ArtifactEducator:
+    """Generates artifact templates for worker deliverables."""
+
+    name = "artifact"
+    domain = "deliverable-templates"
+
+    def generate(
+        self,
+        intent: str,
+        context: dict[str, Any],
+        provider: AgentProvider,
+    ) -> EducatorProposal:
+        kind = str(context.get("artifact_kind", "report"))
+        target_path = f"Agentik_SSOT/templates/{kind}.md"
+        return run_education(
+            educator_name=self.name,
+            domain=self.domain,
+            intent=intent,
+            target_kind="template",
+            target_path=target_path,
+            domain_instructions=_INSTRUCTIONS,
+            context={**context, "artifact_kind": kind},
+            provider=provider,
+            artifact_id=kind,
+        )

package/omega/Agentik_Engine/omega_engine/educators/automation.py

@@ -0,0 +1,76 @@
+"""`automation-educator` — generates hooks, crons, reactors.
+
+The signature: an automation declares a TRIGGER → ACTION binding the supervisor
+runs unattended. Crons (time), hooks (event), reactors (state change). Every
+automation is auditable: it logs to the event store and inherits the deadman.
+
+Target SSOT path: ``Agentik_SSOT/automations/<id>.yaml``.
+"""
+from __future__ import annotations
+
+from typing import Any
+
+from omega_engine.educators.base import EducatorProposal, run_education
+from omega_engine.provider import AgentProvider
+
+_INSTRUCTIONS = """\
+Produce ONE automation config in YAML. The config MUST contain these fields:
+
+  id: <stable identifier, lowercase, kebab-case>
+  kind: cron | hook | reactor
+  description: <one line>
+  trigger:
+    # for cron:  schedule: "<cron expression>"  + timezone: <IANA tz>
+    # for hook:  event: <event.type from the event store>
+    # for reactor: state_from: <FSM state>  state_to: <FSM state>
+    #              kind_filter: <task kind | "*">
+  action:
+    skill: <skill id, OR>
+    command: <shell command, OR>
+    dispatch_role: <role from Agentik_SSOT/agents/>
+  budget:
+    max_iterations: <int>
+    wall_timeout_sec: <int>
+    cost_cap_usd: <number | null>
+  guards:
+    - <a pre-condition predicate the supervisor evaluates before firing>
+  on_failure: log_only | retry_n | escalate
+  observability:
+    heartbeat_sec: <int>             # missed heartbeat = deadman terminal
+    emits: [ <event.type the action emits> ]
+
+The automation MUST NOT:
+  - fire without a heartbeat (silent automations are a debug nightmare).
+  - bypass the audit gate when its action produces artifacts.
+  - declare more than one of (skill, command, dispatch_role) — exactly one.
+  - omit `on_failure` (default behaviour is too important to leave implicit).
+
+Format the artifact as valid YAML — strict.
+"""
+
+
+class AutomationEducator:
+    """Generates automation specs (cron / hook / reactor) for the SSOT."""
+
+    name = "automation"
+    domain = "automations"
+
+    def generate(
+        self,
+        intent: str,
+        context: dict[str, Any],
+        provider: AgentProvider,
+    ) -> EducatorProposal:
+        automation_id = str(context.get("automation_id", "new-automation"))
+        target_path = f"Agentik_SSOT/automations/{automation_id}.yaml"
+        return run_education(
+            educator_name=self.name,
+            domain=self.domain,
+            intent=intent,
+            target_kind="automation",
+            target_path=target_path,
+            domain_instructions=_INSTRUCTIONS,
+            context={**context, "automation_id": automation_id},
+            provider=provider,
+            artifact_id=automation_id,
+        )