@agentikos/omega-os 0.2.0 → 0.19.5

package/omega/Agentik_Engine/omega_engine/__init__.py

@@ -45,6 +45,17 @@ from omega_engine.educators import (
 from omega_engine.bus import EventBus
 from omega_engine.events import Event, EventType
 from omega_engine.executor import Executor, MissionResult
+from omega_engine.integrations import (
+    GraphifyError,
+    GraphifyGraphMissing,
+    GraphifyNotInstalled,
+    GraphifyReport,
+    graphify_install_skill,
+    graphify_into_rag,
+    graphify_load_graph,
+    graphify_version,
+    is_graphify_installed,
+)
 from omega_engine.progress import MissionProgress, ProgressTracker
 from omega_engine.provider import (
     AgentProvider,
@@ -70,7 +81,65 @@ from omega_engine.rag import (
 from omega_engine.reducer import IllegalTransition, reduce, reduce_task
 from omega_engine.router import ModelRouter
 from omega_engine.store import EventStore, SQLiteStore
+from omega_engine.cadence import (
+    CadenceCharter,
+    disable_cadence,
+    list_cadences,
+    remove_cadence,
+    schedule_cadence,
+)
+from omega_engine.pursue import PursueResult, pursue
+from omega_engine.webhooks import (
+    WebhookRegistry,
+    WebhookSpec,
+    generate_test_signature,
+    handle_webhook,
+    load_registry as load_webhook_registry,
+    signature_header_for,
+    verify_signature,
+)
+from omega_engine.skill_discovery import (
+    DiscoveredSkill,
+    Marketplace,
+    SkillAuditIssue,
+    SkillAuditVerdict,
+    SkillInstallResult,
+    audit_skill_file,
+    audit_skill_text,
+    discover_skills,
+    install_skill_from_github,
+    list_curated,
+    load_marketplaces,
+)
 from omega_engine.sync import ClaudeCodeAdapter, SyncEngine
+from omega_engine.done_signal import (
+    DoneSignal,
+    DoneSignalError,
+    attach_audit_to_done,
+    done_path,
+    read_done,
+    session_dir,
+    write_done,
+)
+from omega_engine.envelope import (
+    DISPATCHER_ROLES,
+    EXECUTOR_ROLES,
+    EnvelopeContext,
+    VERIFIER_ROLES,
+    build_envelope,
+)
+from omega_engine.prompts import (
+    find_agent_file,
+    list_available_agents,
+    load_agent_prompt,
+)
+from omega_engine.vault import (
+    list_project_vaults,
+    vault_init,
+    vault_read,
+    vault_status,
+    vault_write,
+)
 from omega_engine.task import (
     TERMINAL,
     Budget,
@@ -81,8 +150,45 @@ from omega_engine.task import (
     Trigger,
 )
 from omega_engine.tools import Tool, ToolRegistry, install_from_catalog
+from omega_engine.worker import (
+    WorkerBrief,
+    default_model_for_role,
+    list_workers,
+    read_brief,
+    run_brief,
+    spawn_worker,
+    wait_for_done,
+    worker_status,
+    write_brief,
+)
+from omega_engine.cleanup import (
+    TierResult,
+    cleanup as run_cleanup,
+    format_summary as cleanup_summary,
+)
+from omega_engine.skill_routing import (
+    POWER_SKILLS,
+    catalog_for_home as skill_catalog_for_home,
+    format_skill_block,
+    recommend as recommend_skills,
+    skills_for,
+)
+from omega_engine.genesis import (
+    GenesisOrchestrator,
+    GenesisState,
+    PhaseResult,
+    Stack,
+    StackConfig,
+    StackQuestion,
+    init_project as genesis_init_project,
+    load_state as genesis_load_state,
+    pick_stack,
+    project_root as genesis_project_root,
+    stack_questions,
+)
+from omega_engine import plan as plan_v7
 
-__version__ = "0.2.0"
+__version__ = "0.19.5"
 
 __all__ = [
     "__version__",
@@ -119,4 +225,44 @@ __all__ = [
     # tool registry + SSOT → provider sync engine
     "Tool", "ToolRegistry", "install_from_catalog",
     "SyncEngine", "ClaudeCodeAdapter",
+    # graphify integration — Claude Code skill + graph consumer
+    "GraphifyError", "GraphifyGraphMissing", "GraphifyNotInstalled",
+    "GraphifyReport",
+    "graphify_install_skill", "graphify_into_rag", "graphify_load_graph",
+    "graphify_version", "is_graphify_installed",
+    # encrypted secrets vault (age if available, chmod 600 fallback)
+    "vault_init", "vault_write", "vault_read", "vault_status",
+    "list_project_vaults",
+    # agent prompt loader (AISB suite + others) + mission envelope
+    "load_agent_prompt", "find_agent_file", "list_available_agents",
+    "EnvelopeContext", "build_envelope",
+    "DISPATCHER_ROLES", "EXECUTOR_ROLES", "VERIFIER_ROLES",
+    # worker .done.json — the structured completion signal
+    "DoneSignal", "DoneSignalError",
+    "write_done", "read_done", "attach_audit_to_done",
+    "session_dir", "done_path",
+    # Agentik OS native primitives (replace Claude Code /goal and /loop on Max)
+    "pursue", "PursueResult",
+    "schedule_cadence", "list_cadences", "disable_cadence", "remove_cadence",
+    "CadenceCharter",
+    # skill discovery + safety audit
+    "Marketplace", "load_marketplaces",
+    "SkillAuditIssue", "SkillAuditVerdict",
+    "audit_skill_file", "audit_skill_text",
+    "DiscoveredSkill", "discover_skills", "list_curated",
+    "SkillInstallResult", "install_skill_from_github",
+    # inbound webhooks — HMAC-signed POSTs that wake autonomous charters
+    "WebhookSpec", "WebhookRegistry",
+    "load_webhook_registry", "signature_header_for",
+    "verify_signature", "handle_webhook", "generate_test_signature",
+    # persistent-tmux workers (smart model per role: opus 1M for coding,
+    # sonnet for planning, haiku for triage)
+    "WorkerBrief", "default_model_for_role",
+    "spawn_worker", "run_brief", "worker_status", "wait_for_done",
+    "list_workers", "read_brief", "write_brief",
+    # OmegaOS-adapted disk cleanup
+    "TierResult", "run_cleanup", "cleanup_summary",
+    # Role → skills routing (worker brief skill palette)
+    "POWER_SKILLS", "skill_catalog_for_home", "format_skill_block",
+    "recommend_skills", "skills_for",
 ]

package/omega/Agentik_Engine/omega_engine/account.py

@@ -282,16 +282,30 @@ def vault_path(omega_home: str | Path, secret_ref: str) -> Path:
 
 
 def read_token(omega_home: str | Path, secret_ref: str) -> str:
-    """Read the OAuth token from the vault file.
-
-    Format: a tiny dotenv-style file with at least `CLAUDE_OAUTH_TOKEN=<value>`.
-    The reader is forgiving: it strips quotes, ignores blank lines and `#`
-    comments, and returns the FIRST value seen for `CLAUDE_OAUTH_TOKEN` (or the
-    canonical key formed by upper-casing the secret_ref).
+    """Read the OAuth token from the vault.
+
+    Resolution order, first match wins:
+      1. ``vault_read(<secret_ref>_TOKEN)`` — the canonical key the new
+         ``write_token`` uses. If age is the active backend the read is
+         transparently decrypted.
+      2. Legacy dotenv file at ``Agentik_Extra/etc/secrets/<secret_ref>.env``
+         with a ``CLAUDE_OAUTH_TOKEN=...`` line. Kept for backward compat
+         with installs that pre-date the encrypted vault.
     """
+    # Local import to avoid an import cycle at module load time.
+    from omega_engine.vault import vault_read
+
+    canon = f"{secret_ref}_TOKEN"
+    try:
+        token = vault_read(omega_home, canon)
+    except ValueError:
+        token = None
+    if token:
+        return token.strip()
+
     path = vault_path(omega_home, secret_ref)
     if not path.exists():
-        raise FileNotFoundError(f"vault file not found: {path}")
+        raise FileNotFoundError(f"vault entry not found for ref {secret_ref!r}")
     keys = ("CLAUDE_OAUTH_TOKEN", secret_ref.upper())
     for line in path.read_text().splitlines():
         s = line.strip()
@@ -309,34 +323,17 @@ def read_token(omega_home: str | Path, secret_ref: str) -> str:
 
 
 def write_token(omega_home: str | Path, secret_ref: str, token: str) -> Path:
-    """Write the OAuth token to the vault file with mode 600.
+    """Write the OAuth token through the vault layer.
 
-    Overwrites silently if a file already exists — rotating a token is the
-    expected use case. Returns the path written.
+    Uses ``omega_engine.vault.vault_write``: age-encrypted if the system has
+    ``age`` + ``age-keygen``, else mode-600 plaintext. Either way, the file
+    is owner-only on disk. Overwrites silently — rotating a token is the
+    expected use case. Returns the actual on-disk path written.
     """
     if not token or not token.strip():
         raise ValueError("token must be a non-empty string")
-    path = vault_path(omega_home, secret_ref)
-    # Use os.open with O_CREAT|O_WRONLY|O_TRUNC and explicit mode so the file
-    # is born with 0o600 (no race window during which 0o644 would be visible).
-    fd = os.open(str(path), os.O_WRONLY | os.O_CREAT | os.O_TRUNC, 0o600)
-    try:
-        with os.fdopen(fd, "w") as fh:
-            fh.write(f"# Omega OS — Claude Max OAuth token for {secret_ref}\n")
-            fh.write(f"# Written: {time.strftime('%Y-%m-%dT%H:%M:%SZ', time.gmtime())}\n")
-            fh.write(f"CLAUDE_OAUTH_TOKEN={token.strip()}\n")
-    finally:
-        # If fdopen succeeded, fd is closed by the context manager; if it
-        # raised, the fd is leaked — guard that by attempting a close.
-        try:
-            os.close(fd)
-        except OSError:
-            pass
-    # Belt-and-braces: re-assert mode in case some umask oddity sneaked in.
-    try:
-        os.chmod(path, stat.S_IRUSR | stat.S_IWUSR)  # 0o600
-    except OSError:
-        pass
+    from omega_engine.vault import vault_write
+    return vault_write(omega_home, f"{secret_ref}_TOKEN", token.strip())
     return path
 
 

package/omega/Agentik_Engine/omega_engine/agent_messages.py

@@ -0,0 +1,167 @@
+"""Worker ↔ Oracle messaging — the missing back-channel.
+
+Today a worker writes a single ``.done.json`` and that's it. If it's
+stuck mid-task and needs the oracle's input, it has no way to ask. Then
+either it guesses wrong (and the audit catches it later — wasted work)
+or it gives up early (status=pending — wasted dispatch).
+
+This primitive is a small JSON-lines file per task at
+``Agentik_Runtime/sessions/<task_id>/messages.jsonl``. The worker
+appends a question, the oracle reads, appends an answer, the worker
+polls and continues.
+
+The protocol is intentionally minimal — one JSON object per line:
+
+  ``{from, to, ts, type, text}``
+
+``type`` is one of:
+
+  * ``question``  — worker asks the oracle
+  * ``answer``    — oracle's reply
+  * ``proposal``  — worker proposes a course change
+  * ``decision``  — oracle says yes/no/pivot
+
+Polling is the operator's choice — the worker can ``read_messages``
+between Bash/Edit iterations. For long-running missions the oracle's
+session can sit in ``omega message wait <task_id>`` to surface
+questions as they arrive.
+"""
+from __future__ import annotations
+
+import json
+import os
+import time
+from dataclasses import dataclass, field
+from pathlib import Path
+
+
+VALID_TYPES = {"question", "answer", "proposal", "decision"}
+
+
+@dataclass
+class Message:
+    from_: str
+    to: str
+    type: str
+    text: str
+    ts: int = field(default_factory=lambda: int(time.time()))
+
+
+def _msg_path(omega_home: str | Path, task_id: str) -> Path:
+    home = Path(omega_home)
+    p = home / "Agentik_Runtime" / "sessions" / task_id / "messages.jsonl"
+    p.parent.mkdir(parents=True, exist_ok=True)
+    return p
+
+
+def send(
+    omega_home: str | Path,
+    task_id: str,
+    *,
+    from_: str,
+    to: str,
+    type: str,
+    text: str,
+) -> Message:
+    """Append one message to the per-task JSONL. Returns the persisted Message."""
+    if type not in VALID_TYPES:
+        raise ValueError(f"type must be one of {VALID_TYPES}, got {type!r}")
+    msg = Message(from_=from_, to=to, type=type, text=text)
+    p = _msg_path(omega_home, task_id)
+    with p.open("a") as fh:
+        fh.write(json.dumps({
+            "from": msg.from_, "to": msg.to,
+            "type": msg.type, "text": msg.text,
+            "ts": msg.ts,
+        }) + "\n")
+    return msg
+
+
+def read(
+    omega_home: str | Path, task_id: str,
+    *,
+    since_ts: int = 0,
+    for_recipient: str | None = None,
+) -> list[Message]:
+    """Read messages for a task. Returns oldest-first."""
+    p = _msg_path(omega_home, task_id)
+    if not p.exists():
+        return []
+    out: list[Message] = []
+    for line in p.read_text().splitlines():
+        if not line.strip():
+            continue
+        try:
+            data = json.loads(line)
+        except json.JSONDecodeError:
+            continue
+        if int(data.get("ts", 0)) < since_ts:
+            continue
+        if for_recipient and data.get("to") != for_recipient:
+            continue
+        out.append(Message(
+            from_=str(data.get("from", "?")),
+            to=str(data.get("to", "?")),
+            type=str(data.get("type", "question")),
+            text=str(data.get("text", "")),
+            ts=int(data.get("ts", 0)),
+        ))
+    return out
+
+
+def wait_for_reply(
+    omega_home: str | Path,
+    task_id: str,
+    *,
+    for_recipient: str,
+    since_ts: int | None = None,
+    timeout_s: int = 600,
+    poll_interval_s: int = 5,
+) -> Message | None:
+    """Block until a message addressed to ``for_recipient`` arrives or timeout.
+
+    Use case: the worker asks a question, then waits for the oracle's
+    answer before continuing. Returns the new message, or None on
+    timeout.
+    """
+    since_ts = since_ts if since_ts is not None else int(time.time())
+    end = time.time() + timeout_s
+    while time.time() < end:
+        msgs = read(omega_home, task_id, since_ts=since_ts,
+                    for_recipient=for_recipient)
+        if msgs:
+            return msgs[0]
+        time.sleep(poll_interval_s)
+    return None
+
+
+def list_open_questions(
+    omega_home: str | Path,
+) -> list[tuple[str, Message]]:
+    """Scan every per-task messages.jsonl for unanswered questions.
+
+    A "question" is unanswered when no later message of type=answer
+    addresses the same conversation. Returns (task_id, question_msg)
+    pairs sorted oldest first.
+    """
+    home = Path(omega_home)
+    sess = home / "Agentik_Runtime" / "sessions"
+    if not sess.is_dir():
+        return []
+    open_qs: list[tuple[str, Message]] = []
+    for child in sess.iterdir():
+        if not child.is_dir():
+            continue
+        p = child / "messages.jsonl"
+        if not p.exists():
+            continue
+        msgs = read(home, child.name)
+        # Questions whose ts is later than the latest answer in the same file
+        latest_answer = max(
+            (m.ts for m in msgs if m.type == "answer"), default=0,
+        )
+        for m in msgs:
+            if m.type == "question" and m.ts > latest_answer:
+                open_qs.append((child.name, m))
+    open_qs.sort(key=lambda pair: pair[1].ts)
+    return open_qs