@agentikos/omega-os 0.19.38 → 0.19.39

package/omega/Agentik_Engine/omega_engine/__init__.py

@@ -188,7 +188,7 @@ from omega_engine.genesis import (
 )
 from omega_engine import plan as plan_v7
 
-__version__ = "0.19.38"
+__version__ = "0.19.39"
 
 __all__ = [
     "__version__",

package/omega/Agentik_Engine/omega_engine/cli.py

@@ -474,6 +474,45 @@ def cmd_doctor(args: argparse.Namespace) -> int:
     except Exception as exc:  # noqa: BLE001
         line("FAIL", f"personas check failed: {exc}")
 
+    # 7c. Prompt audit — each AISB role's prompt must reference the
+    # Three Laws + LMC protocol + done.json contract. Otherwise the
+    # agent runs blind and orchestration breaks at the first dispatch.
+    section("prompts")
+    try:
+        from omega_engine.prompt_audit import audit_aisb_suite
+        rep = audit_aisb_suite(home)
+        if not rep.per_agent:
+            line("warn", "no AISB prompts found — step 25-aisb-suite may have been skipped")
+        else:
+            for r in rep.per_agent:
+                status = "ok" if r.score >= 80 else ("warn" if r.score >= 60 else "FAIL")
+                line(status, f"{r.agent_id}: {r.score}/100"
+                     + (f" — missing: {', '.join(r.violations[:2])}" if r.violations else ""))
+            avg_status = "ok" if rep.average_score >= 80 else "warn"
+            line(avg_status, f"average suite score: {rep.average_score:.1f}/100")
+            if rep.missing_critical:
+                line("warn", f"weak prompts (<60): {', '.join(rep.missing_critical)}")
+    except Exception as exc:  # noqa: BLE001
+        line("FAIL", f"prompt audit failed: {exc}")
+
+    # 7d. Orchestration chain — AISB → Oracle → Worker → Checker must
+    # all be wired and share the LMC protocol vocabulary.
+    section("orchestration")
+    try:
+        from omega_engine.prompt_audit import orchestration_health
+        oh = orchestration_health(home)
+        for k, v in (("aisb_master_present", "AISB master prompt"),
+                     ("oracle_present", "Oracle role prompt"),
+                     ("workers_role_present", "Worker-class prompts"),
+                     ("checker_present", "Checker prompts (Seraph/Smith)"),
+                     ("lmc_protocol_present", "LMC protocol document")):
+            line("ok" if oh.get(k) else "warn", v)
+        overlap = oh.get("shared_vocab_overlap", 0.0)
+        line("ok" if overlap >= 0.6 else "warn",
+             f"shared `.done.json` vocab: {overlap*100:.0f}% of agents")
+    except Exception as exc:  # noqa: BLE001
+        line("FAIL", f"orchestration check failed: {exc}")
+
     # 7b. Per-project vaults
     section("project vaults")
     try:

package/omega/Agentik_Engine/omega_engine/paperclip_bridge.py

@@ -26,6 +26,7 @@ from __future__ import annotations
 import json
 import os
 import shutil
+import socket
 import subprocess
 import time
 from dataclasses import asdict, dataclass, field
@@ -584,3 +585,112 @@ def start_server(bind: str = "loopback", *, detach: bool = True) -> int:
         )
         return proc.pid
     return subprocess.call(args)
+
+
+# ---------------------------------------------------------------------------
+# Live status probe — is the Paperclip dashboard actually running?
+# ---------------------------------------------------------------------------
+
+
+@dataclass
+class PaperclipStatus:
+    """Snapshot of whether the Paperclip dashboard daemon is alive.
+
+    Consumed by the TUI to render ●/○ next to Paperclip menu items so the
+    operator can tell at a glance whether the dashboard is reachable.
+    """
+
+    running: bool
+    pid: int | None         # process PID if alive (None for port-scan hits)
+    port: int | None        # port the dashboard listens on (8080 default)
+    url: str | None         # http://host:port if running, else None
+    detection: str          # "pidfile" | "port-scan" | "none"
+
+
+def is_running(omega_home: Path | str | None = None,
+               *,
+               port: int = 8080,
+               host: str = "127.0.0.1") -> PaperclipStatus:
+    """Probe the Paperclip daemon — running or not?
+
+    Detection strategy (cheap → expensive, returns on first hit):
+      1. Read ``$PAPERCLIP_HOME/run/dashboard.pid`` (default ``~/.paperclip``).
+         If file exists AND ``os.kill(pid, 0)`` succeeds → running.
+      2. Else try TCP connect to ``<host>:<port>`` with a 0.2s timeout.
+         If accept → running but no pidfile (caller may warn).
+      3. Else → not running.
+
+    Never raises. Never blocks more than ~0.3s total.
+
+    Args:
+        omega_home: Accepted for API symmetry with the rest of the bridge;
+            the actual pidfile lives under ``$PAPERCLIP_HOME`` (resolved
+            via :func:`paperclip_home`), not under ``$OMEGA_HOME``.
+        port: TCP port to probe in the fallback path. Default 8080.
+        host: Loopback host to probe. Default 127.0.0.1.
+
+    Returns:
+        :class:`PaperclipStatus` — never None.
+    """
+    del omega_home  # signature consistency only; pidfile lives under PAPERCLIP_HOME
+
+    # ---- 1. Pidfile check (cheapest) -----------------------------------
+    pidfile = paperclip_home() / "run" / "dashboard.pid"
+    if pidfile.exists():
+        try:
+            pid_text = pidfile.read_text().strip()
+            pid = int(pid_text)
+        except (OSError, ValueError):
+            pid = None
+        if pid is not None and pid > 0:
+            alive = False
+            try:
+                os.kill(pid, 0)
+                alive = True
+            except ProcessLookupError:
+                alive = False
+            except PermissionError:
+                # PID exists but is owned by another user — still proves
+                # SOMETHING is alive at that PID, so treat as running.
+                alive = True
+            except OSError:
+                alive = False
+            if alive:
+                return PaperclipStatus(
+                    running=True,
+                    pid=pid,
+                    port=port,
+                    url=f"http://localhost:{port}",
+                    detection="pidfile",
+                )
+            # Stale pidfile — fall through to port scan.
+
+    # ---- 2. Port scan fallback (~0.2s) ---------------------------------
+    sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+    try:
+        sock.settimeout(0.2)
+        try:
+            sock.connect((host, port))
+            return PaperclipStatus(
+                running=True,
+                pid=None,
+                port=port,
+                url=f"http://localhost:{port}",
+                detection="port-scan",
+            )
+        except (OSError, socket.timeout):
+            pass
+    finally:
+        try:
+            sock.close()
+        except OSError:
+            pass
+
+    # ---- 3. Not running -------------------------------------------------
+    return PaperclipStatus(
+        running=False,
+        pid=None,
+        port=None,
+        url=None,
+        detection="none",
+    )

package/omega/Agentik_Engine/omega_engine/prompt_audit.py

@@ -0,0 +1,395 @@
+"""Prompt audit — verify the AISB agent prompts are well-formed AND
+reference the contracts they MUST reference.
+
+Without this, the engine ships agents that read like generic system prompts
+and the Three Laws / LMC protocol / verified-completion (`.done.json`)
+contracts silently drift out of the role files. Orchestration breaks at
+the first dispatch because a worker doesn't know its done-signal contract
+or an oracle doesn't know it must enforce the laws.
+
+The audit applies per-file (each role's prompt is scored in isolation —
+not after the engine concatenates LMC + shared protocols at spawn time)
+because the file on disk is what an operator reads and edits. If a role's
+isolated file is silent on the Three Laws, the operator can't tell the
+contract is present, and any edit that breaks the loader will silently
+strip the laws too.
+
+Public API:
+
+  - ``audit_agent_prompt(path)`` -> AgentPromptReport (score 0..100, checks dict)
+  - ``audit_aisb_suite(omega_home)`` -> SuiteReport (per-agent + averages)
+  - ``orchestration_health(omega_home)`` -> dict of presence + overlap
+
+Only stdlib (``pathlib``, ``re``, ``dataclasses``). No new deps.
+"""
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Optional
+
+
+# ---------------------------------------------------------------------------
+# Data classes — what each audit returns
+# ---------------------------------------------------------------------------
+
+
+@dataclass
+class CheckResult:
+    """One contract check on one prompt file."""
+
+    passed: bool
+    evidence: Optional[str] = None  # short matched snippet, None if not found
+    points: int = 0                  # points awarded for this check
+
+
+@dataclass
+class AgentPromptReport:
+    """Audit result for a single agent prompt .md file."""
+
+    agent_id: str
+    file_path: str
+    score: int = 0                              # 0..100
+    checks: dict[str, CheckResult] = field(default_factory=dict)
+    violations: list[str] = field(default_factory=list)  # human-readable
+
+
+@dataclass
+class SuiteReport:
+    """Audit result for the whole AISB suite."""
+
+    per_agent: list[AgentPromptReport] = field(default_factory=list)
+    average_score: float = 0.0
+    missing_critical: list[str] = field(default_factory=list)   # score < 60
+    orchestration_chain_intact: bool = False
+
+
+# ---------------------------------------------------------------------------
+# Contract patterns — what every well-formed agent prompt should reference
+# ---------------------------------------------------------------------------
+
+
+# Three Laws — case-insensitive search for any of these markers
+_RE_THREE_LAWS = re.compile(
+    r"(three\s+laws|first\s+law|second\s+law|third\s+law|"
+    r"law\s+1|law\s+2|law\s+3)",
+    re.IGNORECASE,
+)
+
+# LMC protocol — concept or filename
+_RE_LMC = re.compile(
+    r"(lmc[\s\-_]*(protocol|gate)?|lead[\s\-]+manager[\s\-]+checker|"
+    r"lmc-protocol\.md)",
+    re.IGNORECASE,
+)
+
+# Verified-completion contract — `.done.json`
+_RE_DONE_JSON = re.compile(r"\.done\.json|done\.json", re.IGNORECASE)
+
+# Done-marker tooling — the script that writes the .done.json signal
+_RE_DONE_MARKER = re.compile(
+    r"(worker[\s\-]?mark[\s\-]?done|oracle[\s\-]?mark[\s\-]?done|"
+    r"mark[\s\-]?done\.sh|write_done\b|done_signal|"
+    r"done[\s\-]?marker)",
+    re.IGNORECASE,
+)
+
+# Scope / role-specific responsibilities — at least one of these tokens
+# tells us the file declares what the agent owns / is allowed to touch.
+_RE_SCOPE = re.compile(
+    r"(scope|files?_owned|owns?\s+R[\s\-]?\d+|responsibilit(y|ies)|"
+    r"^\s*role\b|owned\s+files|files\s+owned|what\s+you\s+own|"
+    r"\bowns\b)",
+    re.IGNORECASE | re.MULTILINE,
+)
+
+# Fresh context handoff vocabulary
+_RE_FRESH_CONTEXT = re.compile(
+    r"fresh[\s\-]+context|self[\s\-]+contained\s+brief|"
+    r"self[\s\-]+contained\s+context",
+    re.IGNORECASE,
+)
+
+# Banned phrases — the no-time-panic global rule (rule 46). These are the
+# action-oriented forms that authorize cheating, NOT the descriptive forms
+# (e.g. "lightweight utility agent" describes a haiku tier — fine).
+# We explicitly DO NOT include bare "lightweight" because templates
+# legitimately describe haiku-tier agents as lightweight (architecture
+# descriptor, not a shortcut authorization).
+_BANNED_PHRASES = [
+    "streamlined approach",
+    "streamlined version",
+    "skip audit",
+    "skip the audit",
+    "quick version",
+    "to save time",
+    "custom scoring",
+    "too heavyweight",
+    "lightweight audit",
+    "simplified protocol",
+]
+
+# Per-check point weights (sum = 100)
+_WEIGHTS = {
+    "three_laws":    25,
+    "lmc_protocol":  15,
+    "done_json":     20,
+    "done_marker":   10,
+    "scope":         15,
+    "fresh_context": 10,
+    "no_banned":      5,
+}
+
+
+# ---------------------------------------------------------------------------
+# Helpers
+# ---------------------------------------------------------------------------
+
+
+def _short_evidence(text: str, match: re.Match) -> str:
+    """Return a short snippet (~60 chars) around the match for the report."""
+    start = max(0, match.start() - 10)
+    end = min(len(text), match.end() + 20)
+    snippet = text[start:end].replace("\n", " ").strip()
+    if len(snippet) > 80:
+        snippet = snippet[:77] + "..."
+    return snippet
+
+
+def _check_pattern(
+    text: str,
+    pattern: re.Pattern,
+    name: str,
+    points: int,
+) -> CheckResult:
+    """Run a regex check and return a CheckResult."""
+    m = pattern.search(text)
+    if m:
+        return CheckResult(passed=True, evidence=_short_evidence(text, m),
+                           points=points)
+    return CheckResult(passed=False, evidence=None, points=0)
+
+
+def _check_no_banned(text: str, points: int) -> CheckResult:
+    """Pass iff no banned phrase appears. The phrase list is short and
+    targets action-oriented patterns (e.g. 'streamlined approach') rather
+    than descriptive ones (e.g. bare 'lightweight') to avoid false
+    positives in legitimate architecture descriptions."""
+    lowered = text.lower()
+    for phrase in _BANNED_PHRASES:
+        if phrase in lowered:
+            return CheckResult(passed=False, evidence=phrase, points=0)
+    return CheckResult(passed=True, evidence=None, points=points)
+
+
+def _agent_id_from_path(path: Path) -> str:
+    """Derive a short agent id from the file path (the .stem)."""
+    return path.stem
+
+
+# ---------------------------------------------------------------------------
+# Public API — single file
+# ---------------------------------------------------------------------------
+
+
+def audit_agent_prompt(path: Path) -> AgentPromptReport:
+    """Score one agent prompt .md file on the seven contract checks.
+
+    Scoring (sum = 100):
+      - Three Laws reference                       25 pts
+      - LMC protocol reference                     15 pts
+      - `.done.json` reference                     20 pts
+      - Done-marker tooling reference              10 pts
+      - Scope / files_owned / responsibilities     15 pts
+      - Fresh context / self-contained brief       10 pts
+      - No banned phrases (rule 46-no-time-panic)   5 pts
+
+    Returns a fully-populated :class:`AgentPromptReport`. If the file does
+    not exist or can't be read, returns a report with score=0 and a single
+    violation explaining why.
+    """
+    path = Path(path)
+    agent_id = _agent_id_from_path(path)
+    report = AgentPromptReport(agent_id=agent_id, file_path=str(path))
+
+    try:
+        text = path.read_text(encoding="utf-8")
+    except (OSError, UnicodeDecodeError) as exc:
+        report.violations.append(f"unreadable file: {exc}")
+        return report
+
+    checks: dict[str, CheckResult] = {
+        "three_laws":    _check_pattern(text, _RE_THREE_LAWS,
+                                        "three_laws",
+                                        _WEIGHTS["three_laws"]),
+        "lmc_protocol":  _check_pattern(text, _RE_LMC,
+                                        "lmc_protocol",
+                                        _WEIGHTS["lmc_protocol"]),
+        "done_json":     _check_pattern(text, _RE_DONE_JSON,
+                                        "done_json",
+                                        _WEIGHTS["done_json"]),
+        "done_marker":   _check_pattern(text, _RE_DONE_MARKER,
+                                        "done_marker",
+                                        _WEIGHTS["done_marker"]),
+        "scope":         _check_pattern(text, _RE_SCOPE,
+                                        "scope",
+                                        _WEIGHTS["scope"]),
+        "fresh_context": _check_pattern(text, _RE_FRESH_CONTEXT,
+                                        "fresh_context",
+                                        _WEIGHTS["fresh_context"]),
+        "no_banned":     _check_no_banned(text, _WEIGHTS["no_banned"]),
+    }
+    report.checks = checks
+
+    # Compute score and violations.
+    score = sum(c.points for c in checks.values())
+    report.score = min(100, score)
+
+    # Human-readable violations for the doctor line summary.
+    human = {
+        "three_laws":    "Three Laws",
+        "lmc_protocol":  "LMC protocol",
+        "done_json":     "`.done.json` contract",
+        "done_marker":   "done-marker tooling",
+        "scope":         "scope/responsibilities",
+        "fresh_context": "fresh context handoff",
+        "no_banned":     "banned phrase present",
+    }
+    for name, res in checks.items():
+        if not res.passed:
+            label = human[name]
+            if name == "no_banned" and res.evidence:
+                label = f"{label} ({res.evidence})"
+            report.violations.append(label)
+
+    return report
+
+
+# ---------------------------------------------------------------------------
+# Public API — full suite
+# ---------------------------------------------------------------------------
+
+
+def _aisb_dir(omega_home: Path) -> Path:
+    return Path(omega_home) / "Agentik_SSOT" / "agents" / "aisb"
+
+
+def _iter_aisb_prompts(omega_home: Path) -> list[Path]:
+    """Return every .md directly under aisb/ (subdirs excluded)."""
+    aisb = _aisb_dir(omega_home)
+    if not aisb.is_dir():
+        return []
+    return sorted(p for p in aisb.iterdir()
+                  if p.is_file() and p.suffix == ".md")
+
+
+def audit_aisb_suite(omega_home: Path) -> SuiteReport:
+    """Audit every .md directly under ``aisb/`` (subdirs excluded).
+
+    Returns a :class:`SuiteReport`. If no prompts are found, ``per_agent``
+    is an empty list and downstream callers should warn (the install
+    step 25-aisb-suite probably was skipped).
+    """
+    omega_home = Path(omega_home)
+    paths = _iter_aisb_prompts(omega_home)
+    per_agent = [audit_agent_prompt(p) for p in paths]
+
+    if per_agent:
+        avg = sum(r.score for r in per_agent) / len(per_agent)
+    else:
+        avg = 0.0
+
+    missing_critical = sorted(r.agent_id for r in per_agent if r.score < 60)
+
+    return SuiteReport(
+        per_agent=per_agent,
+        average_score=avg,
+        missing_critical=missing_critical,
+        orchestration_chain_intact=_chain_intact(per_agent),
+    )
+
+
+def _chain_intact(reports: list[AgentPromptReport]) -> bool:
+    """The AISB → Oracle → Worker chain is intact when:
+      - each of the three roles exists in the suite, AND
+      - all three reference `.done.json` (the shared completion vocabulary).
+
+    'Worker' is taken loosely: morpheus (the canonical executor) or
+    construct (alias target for the generic 'worker' role) satisfies the
+    worker slot. This matches the alias map in ``prompts.py``.
+    """
+    by_id = {r.agent_id: r for r in reports}
+    aisb_master = by_id.get("CLAUDE")  # the master prompt of the AISB suite
+    oracle = by_id.get("oracle")
+    worker = by_id.get("morpheus") or by_id.get("construct")
+
+    if not (aisb_master and oracle and worker):
+        return False
+    return all(r.checks.get("done_json", CheckResult(passed=False)).passed
+               for r in (aisb_master, oracle, worker))
+
+
+# ---------------------------------------------------------------------------
+# Public API — orchestration health
+# ---------------------------------------------------------------------------
+
+
+def orchestration_health(omega_home: Path) -> dict:
+    """Higher-level check: is the AISB → Oracle → Worker → Checker chain
+    wired and does the suite share the verified-completion vocabulary?
+
+    Returns a dict with:
+      - ``aisb_master_present``  — CLAUDE.md exists in aisb/
+      - ``oracle_present``       — oracle.md exists
+      - ``workers_role_present`` — morpheus.md OR construct.md exists
+      - ``checker_present``      — seraph.md OR smith.md exists
+      - ``lmc_protocol_present`` — lmc-protocol.md exists
+      - ``shared_vocab_overlap`` — fraction (0.0..1.0) of agents
+        mentioning `.done.json` in their file
+    """
+    omega_home = Path(omega_home)
+    aisb = _aisb_dir(omega_home)
+
+    def has(name: str) -> bool:
+        return (aisb / name).is_file()
+
+    out: dict = {
+        "aisb_master_present":  has("CLAUDE.md"),
+        "oracle_present":       has("oracle.md"),
+        "workers_role_present": has("morpheus.md") or has("construct.md"),
+        "checker_present":      has("seraph.md") or has("smith.md"),
+        "lmc_protocol_present": has("lmc-protocol.md"),
+    }
+
+    # Shared vocabulary overlap — fraction of agents that reference
+    # `.done.json` in their file. A high overlap means the completion
+    # contract is part of the muscle memory of the suite; a low overlap
+    # means some agents are silent on the done signal and may complete
+    # tasks without writing the structured result downstream consumers
+    # expect.
+    paths = _iter_aisb_prompts(omega_home)
+    if not paths:
+        out["shared_vocab_overlap"] = 0.0
+        return out
+
+    matches = 0
+    for p in paths:
+        try:
+            text = p.read_text(encoding="utf-8")
+        except (OSError, UnicodeDecodeError):
+            continue
+        if _RE_DONE_JSON.search(text):
+            matches += 1
+    out["shared_vocab_overlap"] = matches / len(paths)
+    return out
+
+
+__all__ = [
+    "CheckResult",
+    "AgentPromptReport",
+    "SuiteReport",
+    "audit_agent_prompt",
+    "audit_aisb_suite",
+    "orchestration_health",
+]

package/omega/Agentik_Engine/omega_engine/tmux.py

@@ -325,6 +325,22 @@ def _spawn_with_shell_then_run(
     return name
 
 
+def omega_window_alive(window_name: str) -> bool:
+    """True if a window named ``window_name`` exists inside the Omega
+    master tmux session.
+
+    Used by the TUI chat-list panel to render ● (alive) vs ○ (off) next
+    to AISB-chat / Hermès-chat. Cheap — one ``tmux list-windows`` call;
+    returns False on any error including 'no Omega session'.
+    """
+    if not is_alive("Omega"):
+        return False
+    rc, out = _tmux("list-windows", "-t", "Omega", "-F", "#W")
+    if rc != 0:
+        return False
+    return window_name in (out or "").splitlines()
+
+
 def spawn_chat_in_omega(
     window_name: str,
     *,