@agentikos/omega-os 0.1.0 → 0.19.5

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

@@ -0,0 +1,315 @@
+"""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 (no topic, just a DM to the bot) → log and ignore.
+
+History: every routed message is persisted to
+``Agentik_Runtime/telegram-history.db`` via
+:mod:`omega_engine.telegram_history`. When a topic message arrives, the
+last N exchanges are prepended to the intent — that's the "the bot has
+memory of the conversation" fix.
+
+Routing rule: notifications NEVER go to the AISB DM. They go into the
+project topic the mission was triggered from. The daemon enforces this by
+refusing to start a mission for a message that came in without a
+``message_thread_id``.
+
+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, int | None]:
+    """Pull (topic_id, message_id, text, chat_id) from an update.
+
+    Returns all four; any may be None when the update isn't a text message.
+    We DON'T short-circuit on missing topic_id any more — DM messages now
+    flow through for logging + the operator-may-add-routing later.
+    """
+    msg = update.get("message") or update.get("edited_message") or {}
+    text = msg.get("text")
+    if not text:
+        return None, None, None, None
+    topic_id = msg.get("message_thread_id")
+    message_id = msg.get("message_id")
+    chat = msg.get("chat") or {}
+    chat_id = chat.get("id")
+    return topic_id, message_id, text, chat_id
+
+
+def _route_one(
+    *,
+    topic_id: int | None,
+    text: str,
+    message_id: int | None,
+    chat_id: int | None,
+    supervisor,
+    project_map: dict[int, str],
+    home: Path,
+    telegram_bridge,
+) -> str:
+    """Route one inbound message; return a short tag for the log.
+
+    Now context-aware: every inbound + outbound exchange is persisted to
+    ``telegram-history`` so the Oracle sees the conversation, not just the
+    latest message.
+    """
+    from omega_engine import telegram_history
+
+    # DM (no topic) — log it, refuse to start a mission. AISB DM
+    # is NOT where the orchestration runs; it's where the operator
+    # talks to the bot 1:1. The mission must run inside a project topic.
+    if topic_id is None:
+        # We still record DM history so the operator's question + the
+        # bot's eventual reply (handled elsewhere) are linked.
+        telegram_history.record_inbound(
+            home, topic_id=0, text=text, message_id=message_id,
+        )
+        logger.info(
+            "telegram in: DM (chat=%s) text=%r — refusing to start a "
+            "mission from the DM; ask in a project topic instead",
+            chat_id, text[:80],
+        )
+        if telegram_bridge is not None and chat_id is not None:
+            try:
+                telegram_bridge._call("sendMessage", {  # noqa: SLF001
+                    "chat_id": str(chat_id),
+                    "text": (
+                        "Missions only run from a project topic in the "
+                        "OmegaOS group — not the DM. Open the topic for "
+                        "the project and re-send your request there."
+                    ),
+                })
+            except Exception:  # noqa: BLE001
+                logger.warning("telegram daemon: DM reply failed", exc_info=True)
+        return "dm:refused"
+
+    # Topic message — record + route.
+    telegram_history.record_inbound(
+        home, topic_id=topic_id, text=text, message_id=message_id,
+    )
+
+    # 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 with conversation context
+    slug = project_map.get(topic_id)
+    if slug:
+        # Build a context-aware intent that includes the last N exchanges
+        # in this topic — the Oracle now sees the conversation, not just
+        # the new line. THIS is the "bot has memory" fix.
+        enriched = telegram_history.build_context_prompt(
+            home, topic_id=topic_id, new_intent=text, limit=10,
+        )
+        from omega_engine.mission import run_mission
+        try:
+            outcome = run_mission(
+                intent=enriched,
+                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"
+
+        # Record the bot's summary as an outbound message so the next
+        # inbound in this topic sees it as context.
+        summary = (
+            getattr(outcome, "summary", None)
+            or f"mission {getattr(outcome, 'mission_id', '?')} "
+            f"→ {getattr(getattr(outcome, 'final_state', None), 'value', '?')}"
+        )
+        telegram_history.record_outbound(
+            home, topic_id=topic_id, text=summary[:1000],
+        )
+        return f"project:{slug}"
+
+    # 3. unknown topic — log only; don't start a mission for stranger topics
+    logger.info(
+        "telegram in: unknown topic %s text=%r — no project routes here",
+        topic_id, text[:80],
+    )
+    return "topic:unknown"
+
+
+# ─────────────────────────────────────────────────────────────────────────────
+# 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, chat_id = _extract_message_fields(update)
+            if 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,
+                    message_id=message_id, chat_id=chat_id,
+                    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/done_signal.py

@@ -0,0 +1,154 @@
+"""Worker `.done.json` — the structured completion signal.
+
+Events are the source of truth (event-sourcing). But events are *facts about
+state*, not *artifacts the worker produced*. The done file is the workspace
+artifact: the worker's structured summary of what it did, what's still
+pending, what failed.
+
+Schema
+------
+::
+
+    {
+        "status": "done_clean" | "pending" | "failed",
+        "summary": str,
+        "files_changed": [str, ...],
+        "artifacts": {str: any},
+        "pending_actions": [str, ...],
+        "errors": [str, ...],
+        "audit": {...}              # optional, set by the verifier
+    }
+
+Where it lives
+--------------
+::
+
+    $OMEGA_HOME/Agentik_Runtime/sessions/<task_id>/.done.json
+
+The executor passes this path to the worker through the envelope; the worker
+writes there when finished; the audit gate reads it back before flipping
+VERIFIED. AISB / parent dispatchers can also read it to surface progress.
+"""
+from __future__ import annotations
+
+import json
+import os
+import threading
+from dataclasses import asdict, dataclass, field
+from pathlib import Path
+from typing import Any
+
+
+VALID_STATUSES = {"done_clean", "pending", "failed"}
+
+
+class DoneSignalError(RuntimeError):
+    """The done file is missing, malformed, or claims an invalid status."""
+
+
+@dataclass
+class DoneSignal:
+    status: str = "pending"
+    summary: str = ""
+    files_changed: list[str] = field(default_factory=list)
+    artifacts: dict[str, Any] = field(default_factory=dict)
+    pending_actions: list[str] = field(default_factory=list)
+    errors: list[str] = field(default_factory=list)
+    audit: dict[str, Any] = field(default_factory=dict)
+
+    def to_json(self) -> str:
+        return json.dumps(asdict(self), indent=2, ensure_ascii=False)
+
+
+def session_dir(omega_home: str | Path, task_id: str) -> Path:
+    """Per-task session directory; created on demand with mode 700."""
+    d = Path(omega_home) / "Agentik_Runtime" / "sessions" / task_id
+    d.mkdir(parents=True, exist_ok=True)
+    try:
+        os.chmod(d, 0o700)
+    except OSError:
+        pass
+    return d
+
+
+def done_path(omega_home: str | Path, task_id: str) -> Path:
+    return session_dir(omega_home, task_id) / ".done.json"
+
+
+def write_done(
+    omega_home: str | Path,
+    task_id: str,
+    signal: DoneSignal,
+) -> Path:
+    """Write a DoneSignal as JSON to the session dir, ATOMICALLY.
+
+    Atomicity matters here: ``read_done`` is polled by the audit gate, the
+    Telegram patrol, AISB, and a partial write would make the verifier read
+    half a JSON blob. We write to a temp file in the same dir, fsync, then
+    rename — rename within the same filesystem is atomic.
+    """
+    if signal.status not in VALID_STATUSES:
+        raise DoneSignalError(
+            f"invalid status {signal.status!r} — must be one of {VALID_STATUSES}"
+        )
+    path = done_path(omega_home, task_id)
+    # Unique tmp suffix per call so concurrent writers from different
+    # threads don't clobber each other's intermediate file.
+    tmp = path.with_suffix(
+        path.suffix + f".tmp.{os.getpid()}.{threading.get_ident()}"
+    )
+    # Write + fsync + close. `os.fdopen` takes ownership of `fd` so the
+    # `with` block is responsible for closing — we never double-close.
+    fd = os.open(str(tmp), os.O_WRONLY | os.O_CREAT | os.O_TRUNC, 0o600)
+    with os.fdopen(fd, "w") as fh:
+        fh.write(signal.to_json())
+        fh.flush()
+        try:
+            os.fsync(fh.fileno())
+        except OSError:
+            # tmpfs / network FS may not support fsync — best-effort.
+            pass
+    # Atomic rename. POSIX guarantees same-dir rename is atomic; readers
+    # see either the old file or the new file, never a partial blob.
+    os.replace(tmp, path)
+    return path
+
+
+def read_done(omega_home: str | Path, task_id: str) -> DoneSignal | None:
+    """Read a DoneSignal back. Returns None if the file is missing."""
+    path = done_path(omega_home, task_id)
+    if not path.exists():
+        return None
+    try:
+        data = json.loads(path.read_text())
+    except (json.JSONDecodeError, OSError) as exc:
+        raise DoneSignalError(f"unparseable done file at {path}: {exc}") from exc
+    if not isinstance(data, dict):
+        raise DoneSignalError(f"done file must be a JSON object, got {type(data)}")
+    status = data.get("status", "")
+    if status not in VALID_STATUSES:
+        raise DoneSignalError(
+            f"done file {path} has invalid status {status!r}"
+        )
+    return DoneSignal(
+        status=status,
+        summary=str(data.get("summary", "")),
+        files_changed=list(data.get("files_changed") or []),
+        artifacts=dict(data.get("artifacts") or {}),
+        pending_actions=list(data.get("pending_actions") or []),
+        errors=list(data.get("errors") or []),
+        audit=dict(data.get("audit") or {}),
+    )
+
+
+def attach_audit_to_done(
+    omega_home: str | Path,
+    task_id: str,
+    audit: dict[str, Any],
+) -> None:
+    """Update an existing done file in place with the verifier's verdict."""
+    signal = read_done(omega_home, task_id)
+    if signal is None:
+        signal = DoneSignal(status="pending", summary="(audit-only)")
+    signal.audit = dict(audit)
+    write_done(omega_home, task_id, signal)

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