@agentikos/omega-os 0.2.0 → 0.19.5

package/omega/Agentik_Engine/omega_engine/store.py

@@ -63,42 +63,85 @@ CREATE INDEX IF NOT EXISTS idx_snapshots_task ON snapshots(task_id, ts DESC);
 
 
 class SQLiteStore(EventStore):
-    """Append-only event log on SQLite (WAL). The default store for a VPS."""
+    """Append-only event log on SQLite (WAL). The default store for a VPS.
+
+    Thread-safety
+    -------------
+    The connection is opened with ``check_same_thread=False`` AND every
+    write is serialized through ``self._lock``. Background services
+    (AutonomousSupervisor, Telegram bot, webhook daemon) all share one
+    store from different threads — without this, the first cross-thread
+    call raises ``sqlite3.ProgrammingError`` and the supervisor dies.
+
+    Bug history: pre-v0.13 the lock was missing and a 5-thread fuzz
+    raised 5/5 ProgrammingErrors. Test: tests/test_store_concurrency.py.
+    """
 
     def __init__(self, db_path: str | Path):
+        import threading
         self.db_path = str(db_path)
         Path(self.db_path).parent.mkdir(parents=True, exist_ok=True)
-        self._conn = sqlite3.connect(self.db_path, isolation_level=None)
+        # check_same_thread=False: we serialise via self._lock so the
+        # connection can be safely shared across threads.
+        self._conn = sqlite3.connect(
+            self.db_path, isolation_level=None, check_same_thread=False,
+        )
         self._conn.row_factory = sqlite3.Row
         self._conn.execute("PRAGMA journal_mode=WAL;")
         self._conn.execute("PRAGMA synchronous=NORMAL;")
         self._conn.executescript(_SCHEMA)
+        self._lock = threading.Lock()
+
+    def close(self) -> None:
+        """Explicitly close the SQLite connection (best-effort)."""
+        try:
+            with self._lock:
+                self._conn.close()
+        except (sqlite3.Error, AttributeError):
+            pass
+
+    def __del__(self) -> None:
+        # Best-effort cleanup — Python may have already torn things down.
+        try:
+            self.close()
+        except Exception:  # noqa: BLE001
+            pass
 
     def append(self, event: Event) -> None:
-        self._conn.execute(
-            "INSERT INTO events (id, task_id, type, ts, payload) "
-            "VALUES (:id, :task_id, :type, :ts, :payload)",
-            event.to_row(),
-        )
+        with self._lock:
+            self._conn.execute(
+                "INSERT INTO events (id, task_id, type, ts, payload) "
+                "VALUES (:id, :task_id, :type, :ts, :payload)",
+                event.to_row(),
+            )
 
     def events_for(self, task_id: str) -> list[Event]:
         # ORDER BY rowid = insertion order — the only correct order for a reducer.
         # Ordering by `ts` is unsafe: rapid emits can share a timestamp.
-        cur = self._conn.execute(
-            "SELECT * FROM events WHERE task_id = ? ORDER BY rowid", (task_id,)
-        )
-        return [Event.from_row(dict(r)) for r in cur.fetchall()]
+        with self._lock:
+            cur = self._conn.execute(
+                "SELECT * FROM events WHERE task_id = ? ORDER BY rowid",
+                (task_id,),
+            )
+            rows = cur.fetchall()
+        return [Event.from_row(dict(r)) for r in rows]
 
     def all_events(self, since_ts: float = 0.0) -> Iterator[Event]:
-        cur = self._conn.execute(
-            "SELECT * FROM events WHERE ts >= ? ORDER BY rowid", (since_ts,)
-        )
-        for r in cur.fetchall():
+        # Read all rows under the lock, then yield outside it — long-running
+        # consumers must not hold the write lock.
+        with self._lock:
+            cur = self._conn.execute(
+                "SELECT * FROM events WHERE ts >= ? ORDER BY rowid",
+                (since_ts,),
+            )
+            rows = cur.fetchall()
+        for r in rows:
             yield Event.from_row(dict(r))
 
     def task_ids(self) -> list[str]:
-        cur = self._conn.execute("SELECT DISTINCT task_id FROM events")
-        return [r["task_id"] for r in cur.fetchall()]
+        with self._lock:
+            cur = self._conn.execute("SELECT DISTINCT task_id FROM events")
+            return [r["task_id"] for r in cur.fetchall()]
 
     # --- snapshots --------------------------------------------------------
     # Snapshots are an optional optimisation. Correctness depends only on
@@ -107,11 +150,13 @@ class SQLiteStore(EventStore):
     def snapshot(self, task_id: str) -> dict | None:
         """Capture the current reduced state of a task at the latest event.
         Returns the snapshot row, or None if the task has no events."""
-        cur = self._conn.execute(
-            "SELECT rowid FROM events WHERE task_id = ? ORDER BY rowid DESC LIMIT 1",
-            (task_id,),
-        )
-        row = cur.fetchone()
+        with self._lock:
+            cur = self._conn.execute(
+                "SELECT rowid FROM events WHERE task_id = ? "
+                "ORDER BY rowid DESC LIMIT 1",
+                (task_id,),
+            )
+            row = cur.fetchone()
         if not row:
             return None
         last_rowid = row[0]
@@ -120,22 +165,24 @@ class SQLiteStore(EventStore):
         events = self.events_for(task_id)
         state = reduce_task(events)
         ts = events[-1].ts
-        self._conn.execute(
-            "INSERT OR REPLACE INTO snapshots (task_id, state, ts, last_event_rowid) "
-            "VALUES (?, ?, ?, ?)",
-            (task_id, state.value, ts, last_rowid),
-        )
+        with self._lock:
+            self._conn.execute(
+                "INSERT OR REPLACE INTO snapshots (task_id, state, ts, "
+                "last_event_rowid) VALUES (?, ?, ?, ?)",
+                (task_id, state.value, ts, last_rowid),
+            )
         return {"task_id": task_id, "state": state, "ts": ts,
                 "last_event_rowid": last_rowid}
 
     def latest_snapshot(self, task_id: str) -> dict | None:
         """Latest snapshot for a task, or None."""
-        cur = self._conn.execute(
-            "SELECT state, ts, last_event_rowid FROM snapshots "
-            "WHERE task_id = ? ORDER BY ts DESC LIMIT 1",
-            (task_id,),
-        )
-        row = cur.fetchone()
+        with self._lock:
+            cur = self._conn.execute(
+                "SELECT state, ts, last_event_rowid FROM snapshots "
+                "WHERE task_id = ? ORDER BY ts DESC LIMIT 1",
+                (task_id,),
+            )
+            row = cur.fetchone()
         if not row:
             return None
         from omega_engine.task import TaskState
@@ -147,11 +194,11 @@ class SQLiteStore(EventStore):
         snap = self.latest_snapshot(task_id)
         if not snap:
             return self.events_for(task_id)
-        cur = self._conn.execute(
-            "SELECT * FROM events WHERE task_id = ? AND rowid > ? ORDER BY rowid",
-            (task_id, snap["last_event_rowid"]),
-        )
-        return [Event.from_row(dict(r)) for r in cur.fetchall()]
-
-    def close(self) -> None:
-        self._conn.close()
+        with self._lock:
+            cur = self._conn.execute(
+                "SELECT * FROM events WHERE task_id = ? AND rowid > ? "
+                "ORDER BY rowid",
+                (task_id, snap["last_event_rowid"]),
+            )
+            rows = cur.fetchall()
+        return [Event.from_row(dict(r)) for r in rows]

package/omega/Agentik_Engine/omega_engine/sync.py

@@ -97,11 +97,26 @@ class ClaudeCodeAdapter:
         out_root: Path,
         layout: str,  # "skill" | "command" | "agent"
     ) -> list[str]:
-        """Copy `src/*.md` to the native layout. Returns list of written paths."""
+        """Copy `src/*.md` AND `src/<name>/SKILL.md` to the native layout.
+
+        Both shapes are supported in the SSOT:
+          1. Flat:      ``Agentik_SSOT/skills/pursue.md``
+          2. Directory: ``Agentik_SSOT/skills/pursue/SKILL.md`` (+ optional
+             supporting files like ``scripts/`` or ``examples/``).
+
+        Directory-based skills are the Claude Code idiom — supporting files
+        sit next to ``SKILL.md`` and the agent can reference them via
+        ``${CLAUDE_SKILL_DIR}``. We copy the whole directory verbatim so
+        those references resolve at the destination.
+
+        Returns the list of written paths (relative to ``out_root.parent``).
+        """
         if not src.is_dir():
             return []
         out_root = self._ensure(out_root)
         written: list[str] = []
+
+        # 1. flat: src/<name>.md
         for md in sorted(src.glob("*.md")):
             stem = self._stem(md)
             if layout == "skill":
@@ -111,6 +126,29 @@ class ClaudeCodeAdapter:
                 dest = out_root / f"{stem}.md"
             dest.write_text(md.read_text())
             written.append(str(dest.relative_to(out_root.parent)))
+
+        # 2. directory: src/<name>/SKILL.md (+ supporting files)
+        if layout == "skill":
+            import shutil as _sh
+            for child in sorted(src.iterdir()):
+                if not child.is_dir():
+                    continue
+                skill_md = child / "SKILL.md"
+                if not skill_md.exists():
+                    continue
+                dest_dir = self._ensure(out_root / child.name)
+                # Copy SKILL.md plus any supporting files (scripts/, etc.)
+                for item in child.iterdir():
+                    target = dest_dir / item.name
+                    if item.is_dir():
+                        if target.exists():
+                            _sh.rmtree(target)
+                        _sh.copytree(item, target)
+                    else:
+                        target.write_text(item.read_text())
+                written.append(
+                    str((dest_dir / "SKILL.md").relative_to(out_root.parent))
+                )
         return written
 
     # ----- MCP config (.mcp.json) ---------------------------------------
@@ -230,6 +268,97 @@ class ClaudeCodeAdapter:
         settings_file.write_text(json.dumps(settings, indent=2) + "\n")
         return hooks_block
 
+    # ----- bridge to ~/.claude/ (the dir Claude Code actually reads) -----
+    #
+    # Why this exists
+    # ---------------
+    # ``project()`` writes the SSOT-derived layout into
+    # ``$OMEGA_HOME/Agentik_AI/providers/claude-code/.claude/`` — that tree
+    # stays under OmegaOS for portability (vault backup, audit trail, you
+    # name it). But the ``claude`` CLI on a real workstation reads skills /
+    # commands / agents / .mcp.json from ``~/.claude/`` (user-global) and
+    # ``.claude/`` (project-local).
+    #
+    # Without a bridge, the 24 SSOT skills NEVER become invokable slash
+    # commands. ``link_to_user_claude(home)`` is that bridge: for every
+    # skill we projected, we create a SYMLINK at
+    # ``~/.claude/skills/<id> → $OMEGA_HOME/.../skills/<id>``. This means:
+    #   - editing the SSOT + re-running ``omega sync`` updates the
+    #     skill in place (no duplicate copies),
+    #   - removing the SSOT skill nukes the symlink on the next sync,
+    #   - the operator's existing ``~/.claude/skills/<other>/`` are
+    #     untouched (we only manage entries whose targets are inside
+    #     ``$OMEGA_HOME``).
+
+    def link_to_user_claude(
+        self, omega_home: Path,
+        *,
+        user_claude: Path | None = None,
+    ) -> dict[str, Any]:
+        """Bridge the projected tree into ``~/.claude/`` via symlinks.
+
+        Returns ``{linked_skills, linked_commands, linked_agents,
+                   removed: [stale_paths]}``. Idempotent.
+        """
+        import os as _os
+        user = Path(user_claude) if user_claude else Path.home() / ".claude"
+        target = self.target_dir(omega_home)
+        out: dict[str, Any] = {
+            "user_claude": str(user),
+            "linked_skills": 0,
+            "linked_commands": 0,
+            "linked_agents": 0,
+            "removed": [],
+        }
+        # The provider-tree target must exist first (project() was called).
+        if not target.is_dir():
+            return out
+
+        for layout in ("skills", "commands", "agents"):
+            src_root = target / layout
+            if not src_root.is_dir():
+                continue
+            dest_root = self._ensure(user / layout)
+
+            # Remove stale symlinks we used to manage. A "managed" symlink
+            # points anywhere inside `target`. Real dirs and symlinks owned
+            # by the user are NEVER touched.
+            for child in list(dest_root.iterdir()):
+                if not child.is_symlink():
+                    continue
+                try:
+                    realpath = child.resolve()
+                except OSError:
+                    continue
+                # Only nuke our own — points inside the OmegaOS tree.
+                if str(realpath).startswith(str(target)) and not (src_root / child.name).exists():
+                    try:
+                        child.unlink()
+                        out["removed"].append(str(child))
+                    except OSError:
+                        pass
+
+            for src in sorted(src_root.iterdir()):
+                if not src.is_dir() and not src.suffix == ".md":
+                    continue
+                dest = dest_root / src.name
+                if dest.is_symlink():
+                    try:
+                        dest.unlink()
+                    except OSError:
+                        pass
+                elif dest.exists():
+                    # Don't clobber the user's hand-written content.
+                    continue
+                try:
+                    _os.symlink(src, dest)
+                    out[f"linked_{layout}"] += 1
+                except OSError:
+                    # Some filesystems (Windows WSL crossings) refuse symlinks;
+                    # in that case the user can re-run with --copy.
+                    pass
+        return out
+
     # ----- entry point ---------------------------------------------------
 
     def project(self, omega_home: Path) -> dict[str, Any]:
@@ -243,6 +372,17 @@ class ClaudeCodeAdapter:
         mcp = self._project_mcp(omega_home, target)
         hooks = self._project_hooks(omega_home, target)
 
+        # Bridge to ~/.claude/ so the projected skills actually become
+        # invokable slash-commands. Toggleable via env var (off → only the
+        # provider tree is written; user opts in later with `omega skill link`).
+        link_info: dict[str, Any] = {}
+        import os as _os
+        if _os.environ.get("OMEGA_SYNC_NO_LINK") != "1":
+            try:
+                link_info = self.link_to_user_claude(omega_home)
+            except OSError:
+                link_info = {}
+
         return {
             "provider": self.id,
             "projected": True,
@@ -252,6 +392,7 @@ class ClaudeCodeAdapter:
             "agents_written": len(agents),
             "mcp_servers": len(mcp.get("mcpServers", {})) if isinstance(mcp, dict) else 0,
             "hooks": list(hooks.keys()),
+            "linked_to_user_claude": link_info,
         }
 
 

package/omega/Agentik_Engine/omega_engine/telegram_history.py

@@ -0,0 +1,260 @@
+"""Per-topic conversation history — fixes the "bot has no memory" bug.
+
+When the user types in a Telegram topic, the Telegram daemon used to call
+``run_mission(intent=text)`` with ONLY the new message. The Oracle saw a
+brand-new mission every turn — no idea what the user was actually talking
+about. The user's reply to a follow-up question landed without context.
+
+This module is the fix. It persists every inbound + outbound message per
+topic to a SQLite table; the daemon prepends the last N exchanges to the
+envelope's user message so the agent always has the conversation.
+
+Layout
+------
+``$OMEGA_HOME/Agentik_Runtime/telegram-history.db``
+
+::
+
+    CREATE TABLE messages (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        topic_id INTEGER NOT NULL,        -- forum topic id (or 0 for DM root)
+        role TEXT NOT NULL,                -- 'user' | 'bot'
+        text TEXT NOT NULL,
+        message_id INTEGER,                -- Telegram's own message_id
+        timestamp INTEGER NOT NULL
+    );
+
+Two indexes: one for per-topic recency, one for full-text-ish search.
+
+Public API
+----------
+``record_inbound(home, topic_id, text, message_id=None)``
+``record_outbound(home, topic_id, text, message_id=None)``
+``recent_messages(home, topic_id, limit=20) -> list[Message]``
+``build_context_prompt(home, topic_id, new_intent, limit=10) -> str``
+"""
+from __future__ import annotations
+
+import os
+import sqlite3
+import time
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Iterable
+
+
+@dataclass
+class Message:
+    id: int
+    topic_id: int
+    role: str           # "user" | "bot"
+    text: str
+    message_id: int | None
+    timestamp: int
+
+
+def _db_path(omega_home: str | Path) -> Path:
+    home = Path(omega_home)
+    runtime = home / "Agentik_Runtime"
+    runtime.mkdir(parents=True, exist_ok=True)
+    return runtime / "telegram-history.db"
+
+
+def _connect(omega_home: str | Path) -> sqlite3.Connection:
+    conn = sqlite3.connect(str(_db_path(omega_home)))
+    conn.row_factory = sqlite3.Row
+    conn.execute("PRAGMA journal_mode=WAL")
+    conn.execute("""
+        CREATE TABLE IF NOT EXISTS messages (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            topic_id INTEGER NOT NULL,
+            role TEXT NOT NULL CHECK(role IN ('user', 'bot')),
+            text TEXT NOT NULL,
+            message_id INTEGER,
+            timestamp INTEGER NOT NULL
+        )
+    """)
+    conn.execute("""
+        CREATE INDEX IF NOT EXISTS idx_messages_topic_time
+            ON messages(topic_id, timestamp DESC)
+    """)
+    return conn
+
+
+def _record(
+    omega_home: str | Path,
+    *,
+    topic_id: int,
+    role: str,
+    text: str,
+    message_id: int | None,
+) -> int:
+    """Persist one message. Returns the rowid."""
+    if role not in ("user", "bot"):
+        raise ValueError(f"role must be 'user' or 'bot', got {role!r}")
+    conn = _connect(omega_home)
+    try:
+        cur = conn.execute(
+            "INSERT INTO messages (topic_id, role, text, message_id, timestamp) "
+            "VALUES (?, ?, ?, ?, ?)",
+            (int(topic_id), role, text, message_id, int(time.time())),
+        )
+        conn.commit()
+        return int(cur.lastrowid)
+    finally:
+        conn.close()
+
+
+def record_inbound(
+    omega_home: str | Path,
+    topic_id: int,
+    text: str,
+    *,
+    message_id: int | None = None,
+) -> int:
+    """The user just sent this in the topic. Persist it."""
+    return _record(omega_home, topic_id=topic_id, role="user",
+                   text=text, message_id=message_id)
+
+
+def record_outbound(
+    omega_home: str | Path,
+    topic_id: int,
+    text: str,
+    *,
+    message_id: int | None = None,
+) -> int:
+    """The bot just posted this. Persist it so the next turn has context."""
+    return _record(omega_home, topic_id=topic_id, role="bot",
+                   text=text, message_id=message_id)
+
+
+def recent_messages(
+    omega_home: str | Path,
+    topic_id: int,
+    *,
+    limit: int = 20,
+) -> list[Message]:
+    """Return the last ``limit`` messages for this topic, oldest first.
+
+    The query selects by timestamp DESC then reverses — gives us
+    chronological order with a hard cap.
+    """
+    conn = _connect(omega_home)
+    try:
+        rows = conn.execute(
+            "SELECT * FROM messages WHERE topic_id = ? "
+            "ORDER BY timestamp DESC, id DESC LIMIT ?",
+            (int(topic_id), int(limit)),
+        ).fetchall()
+    finally:
+        conn.close()
+    return [
+        Message(
+            id=int(r["id"]),
+            topic_id=int(r["topic_id"]),
+            role=str(r["role"]),
+            text=str(r["text"]),
+            message_id=(int(r["message_id"])
+                        if r["message_id"] is not None else None),
+            timestamp=int(r["timestamp"]),
+        )
+        for r in reversed(rows)
+    ]
+
+
+def build_context_prompt(
+    omega_home: str | Path,
+    topic_id: int,
+    new_intent: str,
+    *,
+    limit: int = 10,
+) -> str:
+    """Compose a context-aware intent for ``run_mission``.
+
+    Format::
+
+        [Conversation history in topic <id>]
+        user (10 min ago): previous message
+        bot (8 min ago):   previous reply
+        user (just now):   ${new_intent}
+
+        Respond to the user's latest message — the messages above are
+        the conversation so far in this topic; keep your answer
+        consistent with them.
+
+    If there's no prior history, returns ``new_intent`` unchanged so a
+    cold conversation behaves as before.
+    """
+    history = recent_messages(omega_home, topic_id, limit=limit)
+    if not history:
+        return new_intent
+
+    now = int(time.time())
+    lines: list[str] = [
+        f"[Conversation history in topic {topic_id}]"
+    ]
+    for msg in history:
+        delta = now - msg.timestamp
+        when = _humanise_age(delta)
+        lines.append(f"  {msg.role} ({when}): {msg.text}")
+
+    lines.append("")
+    lines.append(f"user (just now): {new_intent}")
+    lines.append("")
+    lines.append(
+        "Respond to the user's latest message — the messages above are "
+        "the conversation so far in this topic; keep your answer "
+        "consistent with them."
+    )
+    return "\n".join(lines)
+
+
+def _humanise_age(seconds: int) -> str:
+    """Format an age in seconds as a short human string."""
+    if seconds < 60:
+        return f"{seconds}s ago"
+    if seconds < 3600:
+        return f"{seconds // 60}m ago"
+    if seconds < 86400:
+        return f"{seconds // 3600}h ago"
+    return f"{seconds // 86400}d ago"
+
+
+def prune(
+    omega_home: str | Path,
+    *,
+    older_than_days: int = 90,
+) -> int:
+    """Drop messages older than ``older_than_days``. Returns rows removed."""
+    cutoff = int(time.time()) - older_than_days * 86400
+    conn = _connect(omega_home)
+    try:
+        cur = conn.execute(
+            "DELETE FROM messages WHERE timestamp < ?", (cutoff,)
+        )
+        conn.commit()
+        return int(cur.rowcount)
+    finally:
+        conn.close()
+
+
+def topic_stats(omega_home: str | Path) -> list[dict]:
+    """For the doctor: a one-row-per-topic summary."""
+    conn = _connect(omega_home)
+    try:
+        rows = conn.execute(
+            "SELECT topic_id, COUNT(*) AS n_msgs, "
+            "       MAX(timestamp) AS last_seen "
+            "FROM messages GROUP BY topic_id ORDER BY last_seen DESC"
+        ).fetchall()
+    finally:
+        conn.close()
+    return [
+        {
+            "topic_id": int(r["topic_id"]),
+            "messages": int(r["n_msgs"]),
+            "last_seen": int(r["last_seen"]),
+        }
+        for r in rows
+    ]