@agentikos/omega-os 0.2.0 → 0.19.6

package/omega/Agentik_Engine/omega_engine/completions.py

@@ -0,0 +1,260 @@
+"""Shell completion scripts for ``omega``.
+
+Generates bash + zsh + fish completion files from the live argparse tree
+so the file always reflects the current command surface — no hand-edited
+completion list to drift.
+
+Files land at:
+
+  * ``$OMEGA_HOME/Agentik_Tools/completions/omega.bash``
+  * ``$OMEGA_HOME/Agentik_Tools/completions/_omega``        (zsh)
+  * ``$OMEGA_HOME/Agentik_Tools/completions/omega.fish``
+
+The ``omega completions install`` CLI sources / symlinks them into the
+right place per shell. Idempotent.
+"""
+from __future__ import annotations
+
+import argparse
+import os
+import shutil
+from dataclasses import dataclass
+from pathlib import Path
+
+
+@dataclass
+class CommandNode:
+    """One node in the omega command tree."""
+    name: str
+    help_text: str = ""
+    subcommands: list["CommandNode"] = None  # type: ignore[assignment]
+
+    def __post_init__(self) -> None:
+        if self.subcommands is None:
+            self.subcommands = []
+
+
+def extract_tree(parser: argparse.ArgumentParser) -> CommandNode:
+    """Walk an argparse parser and produce a CommandNode tree."""
+    root = CommandNode(name="omega", help_text="Omega OS control CLI")
+    # The top-level parser has one subparsers action — find it.
+    for action in parser._actions:                              # noqa: SLF001
+        if isinstance(action, argparse._SubParsersAction):       # noqa: SLF001
+            for name, sub_parser in action.choices.items():
+                root.subcommands.append(_walk(name, sub_parser))
+            break
+    return root
+
+
+def _walk(name: str, parser: argparse.ArgumentParser) -> CommandNode:
+    node = CommandNode(name=name, help_text=(parser.description or "").strip())
+    for action in parser._actions:                              # noqa: SLF001
+        if isinstance(action, argparse._SubParsersAction):       # noqa: SLF001
+            for sub_name, sub_parser in action.choices.items():
+                node.subcommands.append(_walk(sub_name, sub_parser))
+            break
+    return node
+
+
+# ---------------------------------------------------------------------------
+# Bash
+# ---------------------------------------------------------------------------
+
+
+def render_bash(root: CommandNode) -> str:
+    """Generate a bash completion script for the command tree."""
+    # Build a flat map: "omega" → first-level subs;
+    #                  "omega <sub>" → that sub's children, etc.
+    lines: list[str] = [
+        "#!/usr/bin/env bash",
+        "# omega — bash completion (auto-generated by omega completions)",
+        "",
+        "_omega_complete() {",
+        "    local cur prev words cword",
+        "    _init_completion || return",
+        "",
+    ]
+
+    # We compute completion by walking COMP_WORDS skipping flags.
+    lines += [
+        '    local commands="' + " ".join(s.name for s in root.subcommands) + '"',
+        '    if [ $cword -eq 1 ]; then',
+        '        COMPREPLY=( $(compgen -W "$commands" -- "$cur") )',
+        '        return 0',
+        '    fi',
+    ]
+
+    for sub in root.subcommands:
+        if not sub.subcommands:
+            continue
+        children = " ".join(c.name for c in sub.subcommands)
+        lines += [
+            f'    if [ "${{words[1]}}" = "{sub.name}" ] && [ $cword -eq 2 ]; then',
+            f'        COMPREPLY=( $(compgen -W "{children}" -- "$cur") )',
+             '        return 0',
+             '    fi',
+        ]
+
+    lines += [
+        '    COMPREPLY=( $(compgen -f -- "$cur") )',
+        "}",
+        "complete -F _omega_complete omega",
+        "",
+    ]
+    return "\n".join(lines)
+
+
+# ---------------------------------------------------------------------------
+# Zsh
+# ---------------------------------------------------------------------------
+
+
+def render_zsh(root: CommandNode) -> str:
+    """Generate a zsh completion script (uses _arguments / _describe)."""
+    lines: list[str] = [
+        "#compdef omega",
+        "# omega — zsh completion (auto-generated by omega completions)",
+        "",
+        "_omega() {",
+        "    local context state line",
+        "    typeset -A opt_args",
+        "",
+        '    _arguments -C \\',
+        "        '1: :->command' \\",
+        "        '*::arg:->args'",
+        "",
+        "    case $state in",
+        "        command)",
+        "            local -a commands",
+        "            commands=(",
+    ]
+    for sub in root.subcommands:
+        help_one = sub.help_text.split("\n")[0].replace("'", "'\\''")
+        lines.append(f"                '{sub.name}:{help_one[:60]}'")
+    lines += [
+        "            )",
+        "            _describe -t commands 'omega command' commands",
+        "            ;;",
+        "        args)",
+        "            case $line[1] in",
+    ]
+    for sub in root.subcommands:
+        if not sub.subcommands:
+            continue
+        lines += [
+            f"                {sub.name})",
+            "                    local -a subs",
+            "                    subs=(",
+        ]
+        for child in sub.subcommands:
+            help_one = child.help_text.split("\n")[0].replace("'", "'\\''")
+            lines.append(f"                        '{child.name}:{help_one[:60]}'")
+        lines += [
+            "                    )",
+            f"                    _describe -t subcommands '{sub.name}' subs",
+            "                    ;;",
+        ]
+    lines += [
+        "            esac",
+        "            ;;",
+        "    esac",
+        "}",
+        "",
+        "_omega \"$@\"",
+        "",
+    ]
+    return "\n".join(lines)
+
+
+# ---------------------------------------------------------------------------
+# Fish
+# ---------------------------------------------------------------------------
+
+
+def render_fish(root: CommandNode) -> str:
+    """Generate a fish completion script."""
+    lines: list[str] = [
+        "# omega — fish completion (auto-generated by omega completions)",
+        "",
+    ]
+    for sub in root.subcommands:
+        desc = sub.help_text.split("\n")[0].replace("'", "\\'")[:60]
+        lines.append(
+            f"complete -c omega -n '__fish_use_subcommand' -a '{sub.name}' "
+            f"-d '{desc}'"
+        )
+    for sub in root.subcommands:
+        if not sub.subcommands:
+            continue
+        for child in sub.subcommands:
+            desc = child.help_text.split("\n")[0].replace("'", "\\'")[:60]
+            lines.append(
+                f"complete -c omega -n '__fish_seen_subcommand_from "
+                f"{sub.name}' -a '{child.name}' -d '{desc}'"
+            )
+    lines.append("")
+    return "\n".join(lines)
+
+
+# ---------------------------------------------------------------------------
+# Install
+# ---------------------------------------------------------------------------
+
+
+def write_all(omega_home: str | Path, root: CommandNode) -> dict[str, Path]:
+    """Write all three completion files. Returns paths."""
+    out = Path(omega_home) / "Agentik_Tools" / "completions"
+    out.mkdir(parents=True, exist_ok=True)
+    bash = out / "omega.bash"
+    zsh = out / "_omega"
+    fish = out / "omega.fish"
+    bash.write_text(render_bash(root))
+    zsh.write_text(render_zsh(root))
+    fish.write_text(render_fish(root))
+    return {"bash": bash, "zsh": zsh, "fish": fish}
+
+
+def install_for_shell(
+    omega_home: str | Path, shell: str,
+) -> dict[str, str]:
+    """Hook the completion into the operator's shell.
+
+    For each shell we know the conventional install location:
+
+      bash → ``~/.bash_completion.d/omega`` (if it exists) or sourced
+             from ``~/.bashrc``
+      zsh  → ``~/.zsh/completion/_omega`` (fpath addition in ``~/.zshrc``)
+      fish → ``~/.config/fish/completions/omega.fish``
+
+    We never overwrite an existing operator file; we symlink. Returns a
+    summary dict.
+    """
+    home = Path(omega_home)
+    completions = home / "Agentik_Tools" / "completions"
+    if not completions.is_dir():
+        return {"status": "error",
+                "detail": f"{completions} does not exist — "
+                          "run `omega completions write` first"}
+    shell = shell.lower()
+    if shell == "bash":
+        target_dir = Path.home() / ".bash_completion.d"
+        target_dir.mkdir(parents=True, exist_ok=True)
+        link = target_dir / "omega"
+        src = completions / "omega.bash"
+    elif shell == "zsh":
+        target_dir = Path.home() / ".zsh" / "completion"
+        target_dir.mkdir(parents=True, exist_ok=True)
+        link = target_dir / "_omega"
+        src = completions / "_omega"
+    elif shell == "fish":
+        target_dir = Path.home() / ".config" / "fish" / "completions"
+        target_dir.mkdir(parents=True, exist_ok=True)
+        link = target_dir / "omega.fish"
+        src = completions / "omega.fish"
+    else:
+        return {"status": "error", "detail": f"unknown shell: {shell}"}
+
+    if link.is_symlink() or link.exists():
+        link.unlink()
+    link.symlink_to(src)
+    return {"status": "ok", "link": str(link), "src": str(src), "shell": shell}

package/omega/Agentik_Engine/omega_engine/costs.py

@@ -0,0 +1,100 @@
+"""Provider cost rate cards — turn token usage into $.
+
+The ``BillingAggregator`` already aggregates input/output tokens per
+account from the event log. This module multiplies by a per-provider
+rate card and surfaces $ in the CLI.
+
+Rate cards are kept in code (not a YAML the operator edits) because:
+
+  1. Anthropic / OpenAI / Zhipu publish public list prices.
+  2. An out-of-date rate card → wrong projections, but the underlying
+     usage numbers are unaffected. The risk is only in the dashboard,
+     not in any state we depend on.
+  3. We document the rate card date so the operator knows when it was
+     last refreshed.
+
+Updating the rate card is a one-line edit when a provider changes prices.
+The doctor surfaces "rate card from <date>; check if your provider has
+changed prices since" so it's never silent.
+
+NOTE: Rates here are USD per million tokens, current at the date below.
+"""
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+
+RATE_CARD_DATE = "2026-05-23"
+
+
+@dataclass(frozen=True)
+class Rates:
+    """USD per MILLION tokens, input and output."""
+    input_per_million: float
+    output_per_million: float
+
+
+# Most-common models per provider. The model field on the event payload
+# determines which row we use; fall back to a sensible default per provider.
+_RATES: dict[str, dict[str, Rates]] = {
+    "claude": {
+        "claude-opus-4-7":   Rates(input_per_million=15.00, output_per_million=75.00),
+        "claude-sonnet-4-6": Rates(input_per_million= 3.00, output_per_million=15.00),
+        "claude-haiku-4-5":  Rates(input_per_million= 0.25, output_per_million= 1.25),
+        # fallback
+        "default":           Rates(input_per_million= 3.00, output_per_million=15.00),
+    },
+    "openai": {
+        "gpt-4o":        Rates(input_per_million= 2.50, output_per_million=10.00),
+        "gpt-4o-mini":   Rates(input_per_million= 0.15, output_per_million= 0.60),
+        "default":       Rates(input_per_million= 2.50, output_per_million=10.00),
+    },
+    "glm": {
+        "glm-4-plus":  Rates(input_per_million= 5.00, output_per_million=15.00),
+        "glm-4-flash": Rates(input_per_million= 0.00, output_per_million= 0.00),
+        "default":     Rates(input_per_million= 1.00, output_per_million= 2.00),
+    },
+    "deepseek": {
+        "deepseek-chat":      Rates(input_per_million=0.14, output_per_million=0.28),
+        "deepseek-reasoner":  Rates(input_per_million=0.55, output_per_million=2.19),
+        "default":            Rates(input_per_million=0.14, output_per_million=0.28),
+    },
+}
+
+
+def estimate_cost(
+    provider: str,
+    *,
+    input_tokens: int,
+    output_tokens: int,
+    model: str = "default",
+) -> float:
+    """Return cost in USD for the given usage."""
+    table = _RATES.get(provider.lower())
+    if not table:
+        return 0.0
+    rates = table.get(model) or table["default"]
+    return (
+        (input_tokens / 1_000_000) * rates.input_per_million
+        + (output_tokens / 1_000_000) * rates.output_per_million
+    )
+
+
+def project_account_cost(
+    provider: str, account_totals: dict, model: str = "default",
+) -> float:
+    """Take a BillingAggregator row + a provider hint, return $."""
+    return estimate_cost(
+        provider,
+        input_tokens=int(account_totals.get("input_tokens", 0)),
+        output_tokens=int(account_totals.get("output_tokens", 0)),
+        model=model,
+    )
+
+
+def rate_card_summary() -> dict:
+    """For the doctor: the date + which providers we cover."""
+    return {
+        "date": RATE_CARD_DATE,
+        "providers": sorted(_RATES.keys()),
+    }

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

@@ -77,6 +77,9 @@ class _EngineHandler(BaseHTTPRequestHandler):
         self._reply(404, {"error": "not found"})
 
     def do_POST(self) -> None:  # noqa: N802
+        # /webhook/<id> — inbound HMAC-signed webhooks (GitHub/Linear/generic)
+        if self.path.startswith("/webhook/"):
+            return self._handle_webhook()
         if self.path != "/mission":
             self._reply(404, {"error": "not found"})
             return
@@ -112,12 +115,46 @@ class _EngineHandler(BaseHTTPRequestHandler):
             logger.exception("engine HTTP: mission failed")
             self._reply(500, {"error": str(exc)})
 
+    def _handle_webhook(self) -> None:
+        """Inbound webhook gate: verify signature → wake supervisor charters."""
+        from omega_engine.webhooks import handle_webhook
+        length = int(self.headers.get("Content-Length", "0"))
+        body = self.rfile.read(length) if length else b""
+        # Collect headers as a plain dict for the gate.
+        headers = {k: v for k, v in self.headers.items()}
+        # The engine daemon's supervisor is built in main() and exposed
+        # via the handler class attribute (set just before serving).
+        supervisor = getattr(self.server, "supervisor", None)
+        try:
+            result = handle_webhook(
+                _omega_home(), path=self.path,
+                headers=headers, body=body, supervisor=supervisor,
+            )
+        except Exception as exc:  # noqa: BLE001
+            logger.exception("engine HTTP: webhook failed")
+            self._reply(500, {"ok": False, "error": str(exc)})
+            return
+        self._reply(result["status"], {
+            "ok": result["ok"],
+            "reason": result.get("reason", ""),
+            "fired": result.get("fired", []),
+        })
 
-def _serve_http(port: int, stop: threading.Event) -> None:
-    """Run the HTTP API until ``stop`` is set."""
+
+def _serve_http(
+    port: int, stop: threading.Event, supervisor=None,
+) -> None:
+    """Run the HTTP API until ``stop`` is set.
+
+    The ``supervisor`` is exposed as a server attribute so the
+    ``/webhook/<id>`` handler can fire charters on a verified inbound.
+    """
     httpd = ThreadingHTTPServer(("127.0.0.1", port), _EngineHandler)
     httpd.timeout = 1.0
-    logger.info("engine HTTP API on 127.0.0.1:%d", port)
+    # Stash on the server so the handler can find it via self.server.
+    httpd.supervisor = supervisor  # type: ignore[attr-defined]
+    logger.info("engine HTTP API on 127.0.0.1:%d (webhooks: %s)",
+                port, "wired" if supervisor else "disabled")
     while not stop.is_set():
         httpd.handle_request()
     httpd.server_close()
@@ -145,8 +182,20 @@ def main() -> int:
     signal.signal(signal.SIGINT, lambda *_: stop.set())
 
     port = int(os.environ.get("OMEGA_ENGINE_PORT", "8731"))
+    # Build the supervisor once at startup so the HTTP server can fire
+    # webhook-triggered charters. Best-effort: if no charters are
+    # configured, the supervisor is still safe to pass — wake_webhook
+    # just returns an empty list.
+    supervisor = None
+    try:
+        from omega_engine.autonomous import build_supervisor_from_home
+        supervisor = build_supervisor_from_home(home)
+    except Exception:  # noqa: BLE001
+        logger.warning("engine daemon: supervisor unavailable — webhooks disabled",
+                       exc_info=True)
     http_thread = threading.Thread(
-        target=_serve_http, args=(port, stop), daemon=True, name="omega-engine-http",
+        target=_serve_http, args=(port, stop, supervisor),
+        daemon=True, name="omega-engine-http",
     )
     http_thread.start()
 

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

@@ -8,7 +8,18 @@ message:
    → :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.
+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
@@ -103,41 +114,95 @@ def _project_topic_map(home: Path) -> dict[int, str]:
     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."""
+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
+        return None, None, None, None
     topic_id = msg.get("message_thread_id")
     message_id = msg.get("message_id")
-    return topic_id, message_id, text
+    chat = msg.get("chat") or {}
+    chat_id = chat.get("id")
+    return topic_id, message_id, text, chat_id
 
 
 def _route_one(
     *,
-    topic_id: int,
+    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."""
+    """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
+    # 2. project topic → run_mission with conversation context
     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.
+        # 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:
-            run_mission(
-                intent=text,
+            outcome = run_mission(
+                intent=enriched,
                 omega_home=home,
                 topic_id=topic_id,
                 telegram=telegram_bridge,
@@ -145,8 +210,25 @@ def _route_one(
         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}"
-    return "ignored"
+
+    # 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"
 
 
 # ─────────────────────────────────────────────────────────────────────────────
@@ -207,15 +289,17 @@ def main() -> int:
 
         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:
+            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, supervisor=supervisor,
+                    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,
                 )